永久存储缓冲区值

Question

I'm trying to parse the lines of a text file and then store them inside of a vector<string> . I'm coming from a Java background and am confused on how C++ handles assigning stuff to the value of a buffer. Here is my code:

string line;
vector<string> adsList;
ifstream inputFile;
inputFile.open("test.txt");
while(getline(inputFile, line))
{
    adsList.push_back(line);
}

In Java, when adding to a data structure a copy of the object is made and then that copy is inserted. In C++, my understanding is that the data structures only hold references so that any operation is very fast. What is the proper way to achieve what I want to do in C++? I have also tried the following code:

vector<string> adsList;
string line;
ifstream inputFile;
inputFile.open("test.txt");
while(getline(inputFile, line))
{
    string *temp = new string;
    *temp = line;
    adsList.push_back(*temp);
}

With my reasoning here being that creating a new string object and storing that would preserve it after being destroyed each loop iteration. C++ seems to handle this completely opposite of Java and I am having a hard time wrapping my head around it.

edit: here is what test.txt looks like:

item1 item1 item1
item2 item2 item2
item3 item3 item3
item4 item4 item4

I'm trying to store each line as a string and then store the string inside my vector. So the front of the vector would have a string with value "item1 item1 item1".

Answer 1

push_back() makes a copy, so your first code sample does exactly what you want it to do. In fact, all C++ structures store copies by default. You'd have to have a container of pointers to not get copies.

Answer 2

Since you didn't post the entire code, I suggest you try this to see if it is reading the file:

#include <iostream>
#include <fstream>
#include <vector>
using namespace std;

int main() {
  fstream inputFile("test.txt",fstream::in);
  string l;
  vector<string> v;
  while(getline(inputFile,l)) v.push_back(l);
  //Display the content of the vector:
  for(int i = 0; i < v.size(); ++i) {
    cout << v[i] << endl;
  }
  return 0;
}

Answer 3

Your understanding re references is incorrect - Java stored references, C++ stores whatever you ask it to , be it pointers or copies (note you can't store references in stl containers, the equivalent is pointers)

vector::push_back stores a copy of the item being stored in the vector - so you don't have to create a pointer , and new some memory on the heap in order to store the string.

(Internally, there is some heap allocation going on, but that's implementation details of std::string )

What option we do have in C++ is to rather store pointers , and these you have to heap allocate, otherwise when the current stack frame is popped off, the pointers will be pointing to defunct memory... but that is another topic.

See here for a simple working example of your code:

#include <iostream>
#include <vector>
#include <fstream>

int main()
{
    std::vector<std::string> adsList;
    std::string line;
    std::ifstream inputFile;
    inputFile.open("test.txt");

    // read a line from the file - store it in 'line'
    while(getline(inputFile, line))
    {
        // store a *copy* of line in the vector
        adsList.push_back(line);
    }

    // for each element in adsList vector, get a *reference* (note the '&')
    for (std::string& s : adsList)
    {
        std::cout << s << std::endl;
    }

    exit(0);
}

Answer 4

Your initial assumption is incorrect. A copy is (generally) stored in vector (ignoring move operations which were brought in with C++11). Generally, this is the way you want to be operating.

If you are truly worried about speed and want to store references (pointers, actually) to things, you'll want to utilize something like std::unique_ptr or std::shared_ptr . For example:

std::vector<std::unique_ptr<std::string>> adsList;
std::string line;
inputFile.open("test.txt");
while(std::getline(inputFile, line)) {
    adsList.push_back(std::unique_ptr<std::string>(new std::string(line));
}

Generally this is only done if you must be able to modify the values in the container and have the modifications reflected to the original object - in this case you'd use a std::shared_ptr . By far the most common scenario is your first code example.