load a file of 1's and 0's into a char** line by line

Question

I have a file, at the end of each line there is possibly a newline:

111\n
100\n
101

Answer 1

In C++ you can load the lines of a file into an array of byte strings like this:

auto lines_from( istream& is )
    -> vector<string>
{
    string line;
    vector<string> result;
    while( getline( is, line ) )
    {
        result.push_back( line );
    }
    return result;
}

auto main() -> int
{
    vector<string> const lines = lines_from( cin );
    // Use it.
}

Here string is std::string from the <string> header, getline is std::getline from the same header, and vector is std::vector from the <vector> header. I chose to use a descriptive name for the function, lines_from. However, it's commonly named readall.

---

Where you absolutely need a char**, presumably with an assumption of some given buffer size for each string, then you can use a vector of pointers, pointing to buffers that e.g. are managed by a class like this:

class C_strings
{
private:
    vector<string>  buffers_;
    vector<char*>   pointers_;
    int             bufsize_;

    C_strings( C_strings const& ) = delete;
    auto operator=( C_strings const& ) -> C_strings& = delete;

public:
    auto pointer() -> char** { return pointers_.data(); }
    auto bufsize() const -> int { return bufsize_; }

    C_strings( vector<string> const& strings, int const bufsize )
        : buffers_( strings )
        , bufsize_( bufsize )
    {
        pointers_.reserve( buffers_.size() + 1 );
        for( string& s : buffers_ )
        {
            s.reserve( bufsize );
            if( s.empty() or s.back() != '\0' ) { s += '\0'; }
            pointers_.push_back( &s[0] );
        }
        pointers_.push_back( nullptr );
    }

    C_strings( C_strings&& other )
        : buffers_( move( other.buffers_ ) )
        , pointers_( move( other.pointers_ ) )
    {}
};

Then let's say you want to call a double-star function like this:

void doublestarfunc( char** const lines )
{
    using std::cout;
    for( char** pps = lines; *pps != nullptr; ++pps )
    {
        if( strlen( *pps ) < 40 ) { strcat( *pps, " < Oh la la!" ); }
        cout << *pps << '\n';
    }
    cout << '\n';
}

It can be done very simply:

using namespace std;        // cin, cout
int const columns           = 80;
int const cstring_bufsize   = columns + 1;

auto c_strings = C_strings( lines_from( cin ), cstring_bufsize );
doublestarfunc( c_strings.pointer() );

But is it a good idea? No, except when you have to relate to an existing C style API. For C++ code, better restructure it to use C++ std::string throughout.