Thread: Adding to a vector from a function

Are you returning the student by reference from get_student(0)? If not, then the assignment is being added to a temporary student which is probably your problem.

On another note, you should not be using new anywhere in your program. You are leaking memory everywhere. C++ is different than Java. You should just use the constructor of the object to create a temporary value to pass to the vector method which will make its own copy. From the code shown I don't think you need pointers at all.

First, your assignment and student classes (and any other class you use) should have valid copy constructors and copy assignment operators. Whether you need to write them yourself or the default ones are correct depends on the data you are holding. If you are holding strings, vectors, POD types (like int, double, or bool) only, then you don't need to add your own. If you have allocated memory using new, or arrays like C style strings, then you need to make your own.

Second, assuming your classes have valid copying, you shouldn't need pointers at all. You pass objects around as reference parameters. Your store them as objects in the vectors. Here is my example:

Code:

void student::add_assignment(const assignment& hw)
{
   homework.push_back(hw);
}

assignment& student::get_assignment(unsigned int a)
{
   // std::out_of_range exception automatically thrown by at() if a is not valid.
   return homework.at(a);
}

int main()
{
   course asdf("asdf", 1, "me");
   student xyz;
   asdf.add_students(xyz);
   asdf.get_student(0).add_assignment(assignment(90505, true, 'a', 0));
   long g = asdf.get_student(0).get_assignment(0).get_duedate();
   std::cout<<g;
   std::cin>>g;
   return 0;
}

Notice how in main, asfd is declared locally. It will be cleaned up automatically when the function ends (in this case at the end of the program since the function is main()). Your old way you used new but not delete, so the memory was never cleaned up and the destructor for course was never called.

The same thing is true for xyz. Declare it locally so that it will clean itself up automatically. There is no reason to use new. You rarely need to use new in C++ unless you are using dynamic polymorphism (via inheritance).

Notice how xyz was added as a student (assuming you changed add_students to take a reference parameter instead of a pointer). You can pass a local variable and a copy will be added to the vector.

You can also pass a temporary variable, which is what happens when the add_assignment function is called inside main. Instead of creating a named variable like xyz, I just used the assignment constructor to create a temporary variable with those arguments (90505, true, 'a', 0) and passed it to the add_assignment function. That function added a copy of that into the vector.

In none of these places is new required. If for some reason you do use new, you must remember to save a copy of the pointer somewhere until you are done with the object and then clean it up yourself by calling delete. There is no garbage collection, so you must clean the dynamically allocated objects up yourself. That is why it is usually better to just create local objects that are destroyed automatically.