How to load a text file into a char **?

[amphetaman]

Is there a safe (unlikely to cause overflows or segfaults) way to load
a text file into a char ** array? I thought of using getline, but it
needs a fixed-length string, and I don't know how many lines or
characters per line the file has.

[acehreli]

On Jul 18, 11:53*am, [e-mail] wrote:

Is there a safe (unlikely to cause overflows or segfaults) way to load
a text file into a char ** array? I thought of using getline, but it
needs a fixed-length string, and I don't know how many lines or
characters per line the file has.

You have wrong information: getline needs a string, not a fixed-length
one, and string is never fixed-length anyway.

After you read it in to the string, then you can make a copy of the
contents with the c_str() member function.

Ali

[amphetaman]

On Jul 18, 3:29*pm, [e-mail] wrote:

On Jul 18, 11:53*am, [e-mail] wrote:

Is there a safe (unlikely to cause overflows or segfaults) way to load
a text file into a char ** array? I thought of using getline, but it
needs a fixed-length string, and I don't know how many lines or
characters per line the file has.

You have wrong information: getline needs a string, not a fixed-length
one, and string is never fixed-length anyway.

After you read it in to the string, then you can make a copy of the
contents with the c_str() member function.

Ali

I was talking about fstream::getline. I think it takes a char * and a
size argument.

But how would I go about allocating the first part of the array (the
number of lines)?

[Victor Bazarov]

am********@gmail.com wrote:

On Jul 18, 3:29 pm, [e-mail] wrote:

>On Jul 18, 11:53 am, [e-mail] wrote:

>>Is there a safe (unlikely to cause overflows or segfaults) way to load
a text file into a char ** array? I thought of using getline, but it
needs a fixed-length string, and I don't know how many lines or
characters per line the file has.

You have wrong information: getline needs a string, not a fixed-length
one, and string is never fixed-length anyway.

After you read it in to the string, then you can make a copy of the
contents with the c_str() member function.

Ali

I was talking about fstream::getline. I think it takes a char * and a
size argument.

But how would I go about allocating the first part of the array (the
number of lines)?

That would mean you need to read them all out to count them. As I
recall, text editors don't have an array of lines, they keep a linked
list. Perhaps that's what you should consider...

V
--
Please remove capital 'A's when replying by e-mail
I do not respond to top-posted replies, please don't ask

[James Kanze]

On Jul 18, 10:05 pm, Victor Bazarov <[e-mail]:

[e-mail] wrote:

On Jul 18, 3:29 pm, [e-mail] wrote:

On Jul 18, 11:53 am, [e-mail] wrote:

>Is there a safe (unlikely to cause overflows or segfaults)
way to load a text file into a char ** array? I thought of
using getline, but it needs a fixed-length string, and I
don't know how many lines or characters per line the file
has.

You have wrong information: getline needs a string, not a
fixed-length one, and string is never fixed-length anyway.

After you read it in to the string, then you can make a
copy of the contents with the c_str() member function.

I was talking about fstream::getline. I think it takes a
char * and a size argument.

But how would I go about allocating the first part of the
array (the number of lines)?

That would mean you need to read them all out to count them.

Not really. He could always reimplement the logic of
std::vector.

As I recall, text editors don't have an array of lines, they
keep a linked list. Perhaps that's what you should
consider...

I don't think that there's any absolute rule as to how text
editors work. Many, I believe, keep all of the text in a
single, large buffer, and not stored as lines, often keeping the
text before the cursor at the front, the text after the cursor
at the end, and the empty space in the array at the cursor
position.

--
James Kanze (GABI Software) email:ja*********@gmail.com
Conseils en informatique orientée objet/
Beratung in objektorientierter Datenverarbeitung
9 place Sémard, 78210 St.-Cyr-l'École, France, [phone]

[Daniel T.]

am********@gmail.com wrote:

Is there a safe (unlikely to cause overflows or segfaults) way to load
a text file into a char ** array?

A char** array? Are you sure you got that right?

I thought of using getline, but it
needs a fixed-length string, and I don't know how many lines or
characters per line the file has.

// puts the entire contents in a char array
vector<charread( const char* fileName )
{
vector<charresult;
ifstream file( fileName, ios::binary );
char ch;
while ( file.get( ch ) )
result.push_back( ch );
return result;
}

or

// puts the entire contents in a char* array,
// breaks file by newlines.
vector< vector<char read( const char* fileName )
{
vector< vector<char result;
ifstream file( fileName );
string str;
while ( getline( file, str ) ) {
result.push_back( vector<char>( str.begin(), str.end() ) );
result.back().push_back( 0 ); // null terminate each line?
}
return result;
}

I guess for a char** array, you could put each word in a separate
block...

[James Kanze]

On Jul 19, 3:57 am, "Daniel T." <[e-mail]:

[e-mail] wrote:

Is there a safe (unlikely to cause overflows or segfaults)
way to load a text file into a char ** array?

A char** array? Are you sure you got that right?

Maybe he needs to interface with some legacy C code.
(Otherwise, of course, std::vector< std::string is the obvious
choice.)

I thought of using getline, but it needs a fixed-length
string, and I don't know how many lines or characters per
line the file has.

// puts the entire contents in a char array
vector<charread( const char* fileName )
{
vector<charresult;
ifstream file( fileName, ios::binary );
char ch;
while ( file.get( ch ) )
result.push_back( ch );
return result;
}

or

// puts the entire contents in a char* array,
// breaks file by newlines.
vector< vector<char read( const char* fileName )
{
vector< vector<char result;
ifstream file( fileName );
string str;
while ( getline( file, str ) ) {
result.push_back( vector<char>( str.begin(), str.end() ) );
result.back().push_back( 0 ); // null terminate each line?
}
return result;
}

I guess for a char** array, you could put each word in a separate
block...

I think he wants one string per line. But I'd still use a
vector of string for the reading, only converting into char**
once the file had been read, e.g.:

std::vector< std::string tmp ;
std::string line ;
while ( std::getline( file, line ) ) {
tmp.push_back( line ) ;
}
std::vector< char const* result ;
for ( std::vector< std::string >::const_iterator
iter = tmp.begin() ;
iter != tmp.end() ;
++ iter ) {
result.push_back( iter->c_str() ) ;
}
result.push_back( NULL ) ; // if needed.
// use &result[0].

(In fact, I just did exactly this yesterday, to interface with
openldap.)

Note that in this case, you cannot simply return &result[0], and
expect it to work. For obvious reasons, you must use &result[0]
before either tmp or result go out of scope. In a larger
application, the solution, I think would be to create a class
which contained these two members, contructed the above in its
constructor, and had a function to return the char**. (It the
needed type really is char**, as was the case with openldap,
you'll have to const_cast.)

--
James Kanze (GABI Software) email:ja*********@gmail.com
Conseils en informatique orientée objet/
Beratung in objektorientierter Datenverarbeitung
9 place Sémard, 78210 St.-Cyr-l'École, France, [phone]

[Daniel T.]

James Kanze <ja*********@gmail.comwrote:

"Daniel T." <[e-mail]:

[e-mail] wrote:

Is there a safe (unlikely to cause overflows or segfaults)
way to load a text file into a char ** array?

A char** array? Are you sure you got that right?

Maybe he needs to interface with some legacy C code.
(Otherwise, of course, std::vector< std::string is the obvious
choice.)

A vector<stringwould equate to a char* array, not a char** array.

char[] char_array = "hello world";
char*[] char_ptr_array = { "a", "b", "c" };
char**[] char_ptr_ptr_array = ?

Maybe the OP just messed up a bit in his terminology?

I thought of using getline, but it needs a fixed-length
string, and I don't know how many lines or characters per
line the file has.

The below is the same as what I had before, except the last step of
turning the vector<vector<char into a char** is added.

template < typename T >
struct PtrToFirst : unary_function< vector< T >, T* {
T* operator()( vector< char >& vec ) const {
return &vec[0];
}
};

typedef vector< vector< char temp_type;
temp_type tmp;
string str;
while ( getline( file, str ) ) {
tmp.push_back( vector<char>( str.begin(), str.end() ) );
tmp.back().push_back( 0 ); // null terminate each line?
}
vector< char* result;
transform( tmp.begin(), tmp.end(), back_inserter( result ),
PtrToFirst<char>() );
// or the above line could be done with:
//for ( temp_type::iterator it = tmp.begin(); it != tmp.end(); ++it )
// result.push_back( &it->at( 0 ) );
result.push_back( 0 );

char** wow = &vector[0]

I think he wants one string per line. But I'd still use a
vector of string for the reading, only converting into char**
once the file had been read, e.g.:

std::vector< std::string tmp ;
std::string line ;
while ( std::getline( file, line ) ) {
tmp.push_back( line ) ;
}
std::vector< char const* result ;
for ( std::vector< std::string >::const_iterator
iter = tmp.begin() ;
iter != tmp.end() ;
++ iter ) {
result.push_back( iter->c_str() ) ;
}
result.push_back( NULL ) ; // if needed.
// use &result[0].

(In fact, I just did exactly this yesterday, to interface with
openldap.)

Note that in this case, you cannot simply return &result[0], and
expect it to work. For obvious reasons, you must use &result[0]
before either tmp or result go out of scope. In a larger
application, the solution, I think would be to create a class
which contained these two members, contructed the above in its
constructor, and had a function to return the char**. (It the
needed type really is char**, as was the case with openldap,
you'll have to const_cast.)

I agree, but I say avoid the (multiple) const_casts by using a vector<
vector< char instead of a vector< string >.

Note that our solutions are remarkably similar. The only difference is
that I don't have to go through the extra step to remove the const.

[James Kanze]

On Jul 19, 2:43 pm, "Daniel T." <[e-mail]:

James Kanze <[e-mail]:

"Daniel T." <[e-mail]:

[e-mail] wrote:
Is there a safe (unlikely to cause overflows or segfaults)
way to load a text file into a char ** array?

A char** array? Are you sure you got that right?

Maybe he needs to interface with some legacy C code.
(Otherwise, of course, std::vector< std::string is the obvious
choice.)

A vector<stringwould equate to a char* array, not a char** array.

You're right. I was thinking of the more usual case, and just
read it as a typo: an array that you "access" through a char**.

char[] char_array = "hello world";
char*[] char_ptr_array = { "a", "b", "c" };
char**[] char_ptr_ptr_array = ?

Maybe the OP just messed up a bit in his terminology?

Probably. Although there's an outside chance that he wanted an
array of lines, each line being an array of words, I suspect
that that's not really the case.

I thought of using getline, but it needs a fixed-length
string, and I don't know how many lines or characters per
line the file has.

The below is the same as what I had before, except the last
step of turning the vector<vector<char into a char** is
added.

Yes. I was basing my posting on yours, since you seemed to be
the only one posting with the correct approach.

Note that in this case, you cannot simply return &result[0],
and expect it to work. For obvious reasons, you must use
&result[0] before either tmp or result go out of scope. In
a larger application, the solution, I think would be to
create a class which contained these two members, contructed
the above in its constructor, and had a function to return
the char**. (It the needed type really is char**, as was
the case with openldap, you'll have to const_cast.)

I agree, but I say avoid the (multiple) const_casts by using a vector<
vector< char instead of a vector< string >.

That's a possibility. I think it depends. If the data really
is supposed to be immutable, and it's just the legacy interface
which doesn't use const, I prefer the const_cast, since it says
what I mean.

In my case (which by coincidence, showed up two days ago), I was
dealing with data from the client; pushing an std::vector<char>
out to the interface level, when I was logically dealing in
strings, didn't seem appropriate (although I find I often use
vectors of char, instead of strings, at the implementation
level).

Note that our solutions are remarkably similar. The only
difference is that I don't have to go through the extra step
to remove the const.

Great minds think alike:-). I wasn't criticizing your
suggestions, just completing them. I did think it important to
point out that even if the char** was imposed by some sort of
legacy interface, some sort of std::vector was still the
preferred option. I may prefer vector< string and the
const_cast, while you prefer vector< vector< char , but the
difference is peanuts, compared to the difference between one of
those and char** or char *[].

--
James Kanze (GABI Software) email:ja*********@gmail.com
Conseils en informatique orientée objet/
Beratung in objektorientierter Datenverarbeitung
9 place Sémard, 78210 St.-Cyr-l'École, France, [phone]