Simple parsing of a CSV file's line. Also includes a utility file repr.hpp and a main for testing.

csvparserdemo.cpp

#include <iostream> // std::ostream, std::cout, std::cin

#include "simpleCSVParse.hpp" // parseCSVLine, option
#include "repr.hpp" // Repr

// need to make representation for a optional value
template<class T>
struct Repr<option<T>> {
    const option<T>& value;
    explicit Repr(const option<T>& v) : value{v} {}
    friend std::ostream& operator<<(std::ostream& lhs, const Repr& rhs)
    {
        if (rhs.value) return lhs << Repr<T>(*rhs.value);
        else           return lhs << '?';
    }
};

template<class ...Args>
constexpr inline void outputLines(std::ostream& stream, const Args&... values)
{
    ((stream << Repr(values) << ' '), ...);
}

int main()
{
    auto [a, b, c] = parseCSVLine<int,option<int>,int>(std::cin);
    outputLines(std::cout, a, b, c);
    auto [d, e, f] = parseCSVLine<option<char>,option<int>,char>(std::cin);
    outputLines(std::cout, d, e, f);
    auto [g, h, i] = parseCSVLine<option<std::string>,std::string,option<std::string>>(std::cin);
    outputLines(std::cout, g, h, i);
    // test input: 1,,4,,,c,"Bobby, Maximus",mom,,
    // output: 1 ? 4 ? ? 'c' "Bobby, Maximus" "mom" ?
    
    //auto [x,y,z] = parseCSVLine<int, option<int>, std::string>)std::cin);
    // ^ basically expands to this at compile time.
    
    int x;
    option<int> y;
    std::string z;
    { // begin new scope so _s cannot be used
        std::string _s;
        std::getline(std::cin, _s, ',');
        std::stringstream(_s) >> x;
    }
    if (std::cin.eof()) {
        y = nullptr;
    } else if (std::cin.peek() == ',')  {
        y = nullptr;
        std::cin.ignore(1);
    } else {
        int _data; // not accessible outside of the if statement
        std::string _s; // not accessible outside of the if statement
        std::getline(std::cin, _s, ',');
        std::stringstream(_s) >> data;
        y = std::make_unique<int>(std::move(data));
    }
    
    if (std::cin.peek() == '"') {
        std::cin.ignore(1);
        std::getline(stream, s, '"');
        if (std::cin.peek() == ',') std::cin.ignore(1);
    } else {
        std::getline(std::cin, z, ',');
    }
    
    // which is basically what people normally write when parsing a line of CSV data...
}

googlebenchmark.cpp

#include <fstream>

#include <benchmark/benchmark.h>

#include "simpleCSVParse.hpp"

static void BM_parseCSVLine(benchmark::State& state) {
    std::ifstream file("testcsv.csv");
    std::string s;
    std::getline(file, s);
    for (auto _ : state) {
        auto [id, species_name, country, howmany] = parseCSVLine<option<int>,std::string, std::string,option<int>>(file);
    }
}

static void BM_manual(benchmark::State& state) {
    std::ifstream file("testcsv.csv");
    {
        std::string s;
        std::getline(file, s);
    }
    for (auto _ : state) {
        option<int> id, howmany;
        std::string species_name, country;
        {
            int _id = 0;
            std::string s;
            std::getline(file, s, ',');
            std::stringstream(s) >> _id;
            id = _id > 0 ? std::make_unique<int>(std::move(_id)) : nullptr;
        }
        if (file.peek() == '"') {
            file.ignore(1);
            std::getline(file, species_name, '"');
            if (file.peek() == ',') file.ignore(1);
        } else {
            std::getline(file, species_name, ',');
        }
        if (file.peek() == '"') {
            file.ignore(1);
            std::getline(file, country, '"');
            if (file.peek() == ',') file.ignore(1);
        } else {
            std::getline(file, country, ',');
        }
        {
            int _howmany = 0;
            std::string s;
            std::getline(file, s, ',');
            std::stringstream(s) >> _howmany;
            howmany = _howmany == 0 ? std::make_unique<int>(std::move(_howmany)) : nullptr;
        }
    }
}
// Register the function as a benchmark
BENCHMARK(BM_parseCSVLine);
BENCHMARK(BM_manual);

// compile with `g++ googlebenchmark.cpp -std=c++17 -lbenchmark -lbenchmark_main -lpthread -O3

repr.hpp

#ifndef REPR_HPP
#define REPR_HPP
#include <string> // need special handling for quotes
#include <iostream> // std::ostream

template<class T>
struct Repr {
    const T& value;
    explicit Repr(const T& v) : value{v} {}
    friend inline std::ostream& operator<<(std::ostream& lhs, const Repr& rhs)
    {
        return lhs << rhs.value;
    }
};

template<>
struct Repr<char> {
    const char& value;
    explicit Repr(const char& v) : value{v} {}
    friend inline std::ostream& operator<<(std::ostream& lhs, const Repr& rhs)
    {
        return lhs << '\'' << rhs.value << '\'';
    }
};

template<>
struct Repr<std::string> {
    const std::string& value;
    explicit Repr(const std::string& v) : value{v} {}
    friend inline std::ostream& operator<<(std::ostream& lhs, const Repr& rhs)
    {
        return lhs << '"' << rhs.value << '"';
    }
};

#endif

simpleCSVParse.hpp

// Created by Kace Cottam, 4/6/2021
// Last modified 5/4/2021
#ifndef SIMPLE_CSV_PARSE_HPP
#define SIMPLE_CSV_PARSE_HPP

#include <string> // need special handling for quotes

#include <sstream> // std::stringstream
#include <iostream> // std::istream, std::ostream
#include <memory> // std::unique_ptr
#include <utility> // std::tuple, std::apply

// requires C++17
// compile with -std=c++17

template<class T>
using option = std::unique_ptr<T>;

template<class T>
constexpr inline std::istream& safeExtraction(
    std::istream& stream,
    T&& arg,
    const char recordDelim,
    const char)
{
    std::string s;
    std::getline(stream, s, recordDelim);
    std::stringstream(s) >> arg;
    return stream;
}

template<>
inline std::istream& safeExtraction(
    std::istream& stream,
    std::string& s,
    const char recordDelim,
    const char quoteDelim)
{
    if (stream.peek() == quoteDelim) {
        stream.ignore(1);
        std::getline(stream, s, quoteDelim);
        if (stream.peek() == recordDelim) stream.ignore(1);
    } else {
        std::getline(stream, s, recordDelim);
    }
    return stream;
}

template<class T>
constexpr inline std::istream& safeExtraction(
    std::istream& stream,
    option<T>& ptr,
    const char recordDelim,
    const char quoteDelim)
{
    if (stream.eof()) {
        ptr = nullptr;
    } else if (stream.peek() == recordDelim)  {
        ptr = nullptr;
        stream.ignore(1);
    } else {
        T data;
        safeExtraction(stream, data, recordDelim, quoteDelim);
        ptr = std::make_unique<T>(std::move(data));
    }
    return stream;
}

template<class ...Args>
constexpr inline std::tuple<Args...> parseCSVLine(
    std::istream& stream,
    const char recordDelim = ',',
    const char quoteDelim = '"')
{
    std::tuple<Args...> items;
    std::apply(
        [&stream, &recordDelim, &quoteDelim]
        (auto&&... vals) {
            ((safeExtraction(stream, vals, recordDelim, quoteDelim)), ...);
        }, items);
    return items;
}

#endif

testcsv.csv