C++文件转换：pipe分隔为逗号分隔

Question

I am trying to figure out how to turn this input file that is in pipe delimited form into comma delimited. I have to open the file, read it into an array, convert it into comma delimited in an output CSV file and then close all files. I have been told that the easiest way to do is within excel but I am not quite sure how.

#include <iostream>
#include <fstream>
using namespace std;

int main()
{
    ifstream inFile;
    string myArray[5];

    cout << "Enter the input filename:";
    cin >> inFileName;

    inFile.open(inFileName);
    if(inFile.is_open())
    std::cout<<"File Opened"<<std::endl;

    // read file line by line into array
    cout<<"Read";

    for(int i = 0; i < 5; ++i)
    {
       file >> myArray[i];
    }

    // File conversion 

    // close input file
    inFile.close();

    // close output file
    outFile.close();
...

What I need to convert is:

Miles per hour|6,445|being the "second" team |5.54|9.98|6,555.00    
"Ending" game| left at "beginning"|Elizabeth, New Jersey|25.25|6.78|987.01   
|End at night, or during the day|"Let's go"|65,978.21|0.00|123.45    
Left-base night|10/07/1900|||4.07|777.23       
"Let's start it"|Start Baseball Game|Starting the new game to win  

What the output should look like in comma-delimited form:

Miles per hour,"6,445","being the ""second"" team member",5.54,9.98,"6,555.00",    
"""Ending"" game","left at ""beginning""","Denver, Colorado",25.25,6.78,987.01,      
,"End at night, during the day","""Let's go""","65,978.21",0.00,123.45,       
Left-base night, 10/07/1900,,,4.07,777.23,               
"""Let's start it""", Start Baseball Game, Starting the new game to win,         

Answer 1

I will show you a complete solution and explain it to you. But let's first have view on it:

#include <iostream>
#include <vector>
#include <fstream>
#include <regex>
#include <string>
#include <algorithm>

// I omit in the example here the manual input of the filenames. This exercise can be done by somebody else
// Use fixed filenames in this example.
const std::string inputFileName("r:\\input.txt");
const std::string outputFileName("r:\\output.txt");

// The delimiter for the source csv file
std::regex re{ R"(\|)" };

std::string addQuotes(const std::string& s) {
    // if there are single quotes in the string, then replace them with double quotes
    std::string result = std::regex_replace(s, std::regex(R"(")"), R"("")");

    // If there is any quote (") or comma in the file, then quote the complete string
    if (std::any_of(result.begin(), result.end(), [](const char c) { return ((c == '\"') || (c == ',')); })) {
        result = "\"" + result + "\"";
    }
    return result;
}


// Some output function
void printData(std::vector<std::vector<std::string>>& v, std::ostream& os) {
    // Go throug all rows
    std::for_each(v.begin(), v.end(), [&os](const std::vector<std::string>& vs) {
        // Define delimiter
        std::string delimiter{ "" };
        // Show the delimited strings
        for (const std::string& s : vs) {
            os << delimiter << s;
            delimiter = ",";
        }
        os << "\n";
    });
}

int main() {


    // We first open the ouput file, becuse, if this cannot be opened, then no meaning to do the rest of the exercise
    // Open output file and check, if it could be opened
    if (std::ofstream outputFileStream(outputFileName); outputFileStream) {

        // Open the input file and check, if it could be opened
        if (std::ifstream inputFileStream(inputFileName); inputFileStream) {

            // In this variable we will store all lines from the CSV file including the splitted up columns
            std::vector<std::vector<std::string>> data{};

            // Now read all lines of the CSV file and split it into tokens
            for (std::string line{}; std::getline(inputFileStream, line); ) {

                // Split line into tokens and add to our resulting data vector
                data.emplace_back(std::vector<std::string>(std::sregex_token_iterator(line.begin(), line.end(), re, -1), {}));
            }
            std::for_each(data.begin(), data.end(), [](std::vector<std::string>& vs) {
                std::transform(vs.begin(), vs.end(), vs.begin(), addQuotes);
            });

            // Output, to file
            printData(data, outputFileStream);

            // And to the screen
            printData(data, std::cout);
        }
        else {
            std::cerr << "\n*** Error: could not open input file '" << inputFileName << "'\n";
        }

    }
    else {
        std::cerr << "\n*** Error: could not open output file '" << outputFileName << "'\n";
    }
    return 0;
}

So, then let's have a look. We have function

• main , read csv files, split it into tokens, convert it, and write it
• addQuotes . Add quote if necessary
• printData print he converted data to an output stream

Let's start with main . main will first open the input file and the output file.

The input file contains a kind of structured data and is also called csv (comma separted values). But here we do not have a comma, but a pipe symbol as delimter.

And the result will be typically stored in a 2d-vector. In dimension 1 is the rows and the other dimension is for the columns.

So, what do we need to do next? As we can see, we need to read first all complete text lines form the source stream. This can be easily done with a one-liner:

for (std::string line{}; std::getline(inputFileStream, line); ) {

As you can see here , the for statement has an declaration/initialization part, then a condition, and then a statement, carried out at the end of the loop. This is well known.

We first define a variable "line" of type std::string and use the default initializer to create an empty string. Then we use std::getline to read from the stream a complete line and put it into our variable. The std::getline returns a reference to sthe stream, and the stream has an overloaded bool operator, where it returns, if there was a failure (or end of file). So, the for loop does not need an additional check for the end of file. And we do not use the last statement of the for loop, because by reading a line, the file pointer is advanced automatically.

This gives us a very simple for loop, fo reading a complete file line by line.

Please note: Defining the variable "line" in the for loop, will scope it to the for loop. Meaning, it is only visible in the for loop. This is generally a good solution to prevent the pollution of the outer name space.

OK, now the next line:

data.emplace_back(std::vector<std::string>(std::sregex_token_iterator(line.begin(), line.end(), digit), {}));

Uh Oh, what is that?

OK, lets go step by step. First, we obviously want to add someting to our 2-dimensionsal data vector. We will use the std::vector s functionemplace_back . We could have used also used push_back , but this would mean that we need to do unnecessary copying of data. Hence, we selected emplace_back to do an in place construction of the thing that we want to add to our 2-dimensionsal data vector.

And what do we want to add? We want to add a complete row, so a vector of columns. In our case a std::vector<std::string> . And, becuase we want to do in inplace construction of this vector, we call it with the vectors range constructor. Please see here: Constructor number 5 . The range constructor takes 2 iterators, a begin and an end iterator, as parameter, and copies all values pointed to by the iterators into the vector.

So, we expect a begin and an end iterator. And what do we see here:

• The begin iterator is: std::sregex_token_iterator(line.begin(), line.end(), digit)
• And the end iterator is simply {}

But what is this thing, the sregex_token_iterator ?

This is an iterator that iterates over patterns in a line. And the pattern is given by a regex . You may read here about the C++ regex libraray. Since it is very powerful, you unfortunately need to learn about it a little longer. And I cannot cover it here. But let us describe its basic functionality for our purpose: You can describe a pattern in some kind of meta language, and the std::sregex_token_iterator will look for that pattern, and, if it finds a match, return the related data. In our case the pattern is very simple: Digits. This can be desribed with "\d+" and means, try to match one or more digits.

Now to the {} as the end iterator. You may have read that the {} will do default construction/initialization. And if you read here, number 1 , then you see that the "default-constructor" constructs an end-of-sequence iterator. So, exactly what we need.

---

After we have read all data, we will transform the single strings, to the required output. This will be done with std::transform and the function addQuotes . The strategy here is to first replace the single quotes with double quotes.

And then, next, we look, if there is any comma or quote in the string, then we enclose the whole string additionally in quotes.

And last, but not least, we have a simple output function and print the converted data into a file and on the screen.