In C++, how do I push an object to a vector while maintaining a pointer to the object?

In my code, I have a vector of Student objects.

vector<Student> m_students;

I want to:

1. Check to see if the vector contains any Student of a certain name.
2. If no such Student exists, add a new one.
3. Add data to the Student of that name.

Consider the following code:

// Check to see if the Student already exists.
Student* targetStudent = NULL;
for each (Student student in m_students)
{
    if (student.Name() == strName)
    {
        targetStudent = &student;
        break;
    }
}

// If the Student didn't exist, add it.
if (targetStudent == NULL)
{
    targetStudent = new Student(strName);
    m_students.push_back(*targetStudent);
}

// Add the course info to the Student.
targetStudent->Add(strQuarter, strCourse, strCredits, strGrade);

When I make the call to m_students.push_back(*targetStudent); it seems that the vector "m_students" ends up with a copy of the Student object that "targetStudent" points to at that time.

The subsequent attempt to add to targetStudent开发者_如何学Python does not change the object contained in the vector.

How can I, starting with a pointer to an object, add that object to a vector and then access the object that is in the vector?

Get the pointer to the object after it was inserted into the vector, so instead of

targetStudent = new Student(strName);
m_students.push_back(*targetStudent);

use

m_students.push_back(Student(strName));
targetStudent = &m_students.back();

Also note that your example leaks memory, the targetStudent copied into the vector is never deleted.

Furthermore keep in mind that the pointers into the vector become invalid when new elements are added (if the vector increases in phsyical size and elements have to be copied into the new, larger vector all pointers into the previous buffer become invalid).

STL containers copy the objects they contain. There is no way to work around this.

You can, however, have a std::vector<std::shared_ptr<Student> >, which allow you to have a container of smart pointers. For this to work, though, your objects must all be attached to the shared_ptr at the time of construction.

So, something like:

std::vector<std::shared_ptr<Student> > m_students;

std::shared_ptr<Student> targetStudent;
for each (std::shared_ptr<Student> student in m_students)
{
        if (student->Name() == strName)
        {
                targetStudent = student;
                break;
        }
}

// If the Student didn't exist, add it.
if (!targetStudent)
{
        // creates a new Student and attaches it to smart pointer
        targetStudent.reset(new Student(strName));
        m_students.push_back(targetStudent);
}

std::shared_ptr is defined in the <memory> header in C++11. (In TR1, you can use std::tr1::shared_ptr instead.) If you're using C++98 without TR1, or need to be portable with it, you can use boost::shared_ptr instead; download from Boost.

You've already gotten a reasonably direct answer to your question. Based on what you seem to be trying to accomplish, however, it seems to me that a less direct answer may really be a better one.

At least as I read your description, you have a number of unique students, and a number of courses for each. When a student has completed a course, you want to look for the student. If they're not in the collection, add them. Then add the data for the course they completed.

That being the case, a vector strikes me as a less than ideal solution. You could implement code a couple of different ways, but I'd probably do it like this:

struct course { 
    std::string Quarter_, Course_, Credits_, Grade_;

    using std::string;
    course(string const &q, string const &c, string const &cr, string const &g) 
        : Quarter_(q), Course_(c), Credits_(cr), Grade_(g)
    {}
};

std::map<std::string, std::vector<course> > m_students;

Using this, your entire sequence to look up a student, insert a new student if there isn't one by that name, then adding the course work to the (new or existing) student's record would work out as:

m_students[strName].push_back(course(strQuarter, strCourse, strCredits, strGrade));

Getting back to your original question, the standard containers are intended to work with values. You pass a value to them, and they store a copy of that value. One consequence of that is that anything like push_back(new XXX) is essentially always a mistake (pretty much a guaranteed memory leak). If you have an object, just pass it. If you don't, just create a temporary and pass that. In Java (for one example) seeing new XXX all over the place is routine and nearly unavoidable. While you can write C++ that way as well, it's not something you should expect as a rule.