Increasing the size of the custom objects array in c++ - c++

Question

I have a class Student and the dynamically created array of students:
class Student{
public:
void create(){
system("cls");
cout << "First name: ";
cin >> fn;
cout << "Last name: ";
cin >> ln;
cout << "How many subjects? ";
cin >> sub_number;
subjects = new string[sub_number];
for(int i = 0; i < sub_number; i++){
cout << "Subject name: ";
cin >> subject[i];
}
}
//This just display the student with a bunch of couts
friend ostream& operator<<(ostream&, const Student&);
~Student(){ delete[] subjects; }
private:
string fn;
string ln;
string* subjects;
int sub_number;
};
I need to increase the size of this array by 1 and add a new student to it.
When I tried to do it by simply:
void main(){
int stu_number = 0;
cout << "How many students? "
cin >> stu_number;
Student* students = new Student[stu_number];
//creating/updating initial students using user input
for(int i = 0; i < stu_number; i++){
students[i].create();
}
//displaying all students
for(int i = 0; i < stu_number; i++){
cout << students[i];
}
//trying to add a student
add_new_student(students, stu_number);
//displaying all students again
for(int i = 0; i < stu_number; i++){
cout << students[i];
}
}
And the add_new_student function:
void add_new_student(Student* students, int& stu_number){
Student* temp = new Student[stu_number++];
for (int i = 0; i < stu_number - 1; i++){
temp[i] = students[i];
}
temp[stu_number - 1].create();
delete[] students;
students = temp;
}
I am getting memory violation errors and Unhandled exceptions: Access violation writing location 0xABABABAB inside the add_new_student function.
What will be the correct way of doing this?
Is Student class missing some important components?
I can't use std::vector or a std::list as this is a school assignment:)

Answer 1

To increase the size of the array, you basically have to:
Create a new array with a larger size
Copy over the values from the old smaller array to the new larger one
Delete the old smaller array
That being said, if you are able to I would recommend switching to std::vector since it has utility methods that will resize for you.

Answer 2

The problem is that your Student class does not follow the "rule of 3":
What is The Rule of Three?
If your class has a user-defined destructor, then it should also provide a user-defined copy constructor and assignment operator. What is happening now is that when this line is performed:
temp[i] = student[i];
you are invoking the assignment operator. However, your Student object, when assigned, will just copy the pointer value from one object to the other. What happens when the destructor for either of these Student objects is called? The destructor will delete the same pointer value twice, thus an error.
Here is a slimmed down version of your current Student class.
#include <string>
class Student
{
std::string* subjects;
std::string fn;
std::string ln;
int sub_number;
public:
Student(size_t numSubjects=5) : subjects(new std::string[numSubjects]),
sub_number(numSubjects){}
~Student() { delete [] subjects; }
};
// Test code
int main()
{
Student s1(10);
Student s2 = s1;
Student s3;
s3 = s1;
}
If you run this program, you will see that there are problems with memory leaks and double deletion errors, as shown here: http://ideone.com/MQhpcK
All I'm doing is copying Student objects, and the issue appears.
To fix the problem, you must add and implement these functions in your Student class:
Student(const Student& rhs); // copy constructor
Student& operator=(const Student& rhs); // assignment operator
Once you implement these functions, test the program above to ensure it truly does make the copies correctly, without memory leaks and segmentation faults/access violation errors. When done, your original issue of the copying causing the access violation should be resolved.

Answer 3

Your problem is caused by the missing assignment operator. In the assignment within the for loop, there is a flat copy of the subjects array which is deleted when the original students array is deleted. After that, there is a so-called dangling pointer in first Student object.
The assignment operator has the job to safely (and semantically correct) copy all elements from one object to another.
Additionally: It would be really interesting (informative) to add some trace output as to get a detailed understanding what's going on here.

Answer 4

Whatever create is called for[1], there must be something wrong with the default constructor[2] of your Student class: it seems to miss initializing important elements that are used within create.
[1] BTW: what is the purpose of create?
[2] Is there a default constructor? What C++ standard is used?