Question

Pretty self-explanatory, I tried google and got a lot of the dreaded expertsexchange, I searched here as well to no avail. An online tutorial or example would be best. Thanks guys.

Answer 1

If what you’re really doing is manipulating a CSV file itself, Nelson’s answer makes sense. However, my suspicion is that the CSV is simply an artifact of the problem you’re solving. In C++, that probably means you have something like this as your data model:

struct Customer {     int id;     std::string first_name;     std::string last_name;     struct {         std::string street;         std::string unit;     } address;     char state[2];     int zip; }; 

Thus, when you’re working with a collection of data, it makes sense to have std::vector<Customer> or std::set<Customer>.

With that in mind, think of your CSV handling as two operations:

// if you wanted to go nuts, you could use a forward iterator concept for both of these class CSVReader { public:     CSVReader(const std::string &inputFile);     bool hasNextLine();     void readNextLine(std::vector<std::string> &fields); private:     /* secrets */ }; class CSVWriter { public:     CSVWriter(const std::string &outputFile);     void writeNextLine(const std::vector<std::string> &fields); private:     /* more secrets */ }; void readCustomers(CSVReader &reader, std::vector<Customer> &customers); void writeCustomers(CSVWriter &writer, const std::vector<Customer> &customers); 

Read and write a single row at a time, rather than keeping a complete in-memory representation of the file itself. There are a few obvious benefits:

1. Your data is represented in a form that makes sense for your problem (customers), rather than the current solution (CSV files).
2. You can trivially add adapters for other data formats, such as bulk SQL import/export, Excel/OO spreadsheet files, or even an HTML <table> rendering.
3. Your memory footprint is likely to be smaller (depends on relative sizeof(Customer) vs. the number of bytes in a single row).
4. CSVReader and CSVWriter can be reused as the basis for an in-memory model (such as Nelson’s) without loss of performance or functionality. The converse is not true.