Re: reading a Text-File into Vector of Strings

arnuld wrote:


  I feel from your code that you lack basic understanding of C++ types,
pointers, and how they work and are used.

  I wonder if you even understand what "ifstream" is and what
"ifstream*" means.

  In that function you create a new ifstream and then open it,
suspiciously with the same name as your first function parameter, ie.
"my_file". This makes me suspect that you think that you are opening
that "file" represented by the first function parameter, called
"my_file", by giving the name of that variable, as a string none the
less, to a second ifstream.

  The variable named my_file and the string "my_file" have *nothing*
to do with each other. They have absolutely no relation. One is a
variable (in this case of type "pointer-to-ifstream") and the other is
a string literal. Just because the string literal has the same
characters as the name of that variable don't make them related in any way.

  Just the fact that you seem to try to be opening an ifstream with
another ifstream seems to show that you don't really understand what the
ifstream class is.


  You do understand that psvec is *not* a vector, but a pointer (and
nothing more than a pointer), and that you are not even making it to
point anywhere? psvec is basically an uninitialized pointer (which could
point basically anywhere and will most probably cause a crash if you try
to read/write it).

  svec *is* a vector, but you are not using it for anything. I'm just
wondering what exactly is it that you expect those two lines to mean.

  If you want to have a vector (such as svec above), you don't need to
explicitly create a pointer in order to be able to pass that vector to
a function as a pointer (or, preferably, as a reference). There's no
need to explicitly create a pointer just to do that.

  For example, let's assume we have somewhere a function like this:

void foo(std::vector<std::string>& aVector) { ... }

  This takes a vector as reference. In other words, a copy of the vector
is *not* given to this function when it's called, but instead just a
reference to the original vector. (You can think of references as
limited pointers.)

  Somewhere else you could write this:

std::vector<std::string> myVector;
foo(myVector);

  The first line creates an vector, and the second line calls the foo()
function giving that vector as parameter. But as already seen, the
function doesn't actually take a copy of the vector, but a reference to
it, and thus any modification the function makes to that vector will be
done to the 'myVector' vector.

  You could, of course, pass a pointer to your original vector too
(although a reference is usually recommended). In that case you make the
function to take a pointer:

void foo(std::vector<std::string>* aVector) { ... }

and then you can call it like this:

std::vector<std::string> myVector;
foo(&myVector);

  The & operator means "create a pointer pointing to this variable".
Thus the foo() function is given a pointer to 'myVector', and if foo()
modifies the vector behind the pointer, 'myVector' will be modified.

  In neither case you need to explicitly create a pointer variable,
like you did. (And even if you created one, you would have to,
naturally, make it point somewhere and not leave it uninitialized like
you did.)


  I'm left wondering why you put those two things in the same line.
Was it just an oversight, or are you trying to express some relation
between the two things? (Because there isn't, of course.)

  And again, you create an ifstream variable, and immediately after that
(below) an uninitialized pointer of the same type. It strongly seems
that you expect some kind of relation between them, although there is
none. 'my_file' and 'p_my_file' are two different variables. They have
no relation to each other. (There could be some relation if you put the
latter to point to the former, but you didn't even do that.)


  This, again, seems to show that you don't really understand what
ifstream is.

  First you ask for a file *name*, in other words, a *string*, and then
you try to read that name directly into the ifstream pointer.

  An ifstream is not a string. It's a class which you can use to read a
file. You can't ask the user for a string and somehow read it into an
ifstream, much less into an ifstream *pointer*. (Again, a pointer is
*not* an ifstream, it's just a pointer. Internally it's nothing more
than a memory address. It's *not* an instance of an ifstream class.)

  What you want is to read a *string* from the user, and then use that
to open the file. Something like this:

std::string fileName;
std::cin >> fileName;
std::ifstream inputFileStream;
inputFileStream.open(fileName.c_str());

  (The ".c_str()" part is necessary because, for whatever reason, the
C++ standard committee decided that ifstream will not support a
std::string directly. Anyways, it's largely irrelevant here. For now,
just memorize this little annoyance.)

  Btw, the last two lines could be shortened to:

std::ifstream inputFileStream(fileName.c_str());

  Reading the lines in the file into the vector can be done in a
relatively simple way, using the std::getline() function in a loop.
For example, something like this:

std::vector<std::string> lines;
std::string line;

while(inputFileStream.good())
{
    std::getline(inputFileStream, line);
    lines.push_back(line);
}

  That's it. It doesn't need to be more complicated than that.