Setting constructor and destructor with *pointer array C++ - c++

Question

I am using int *studentsAge to store a list of ages, and double *marks[2] to store a list of 2 marks per student.
Basically, I am not sure how to set my constructor and destructor.
This is my constructor...
Students::Students()
{
num = 0;
studentsAge = NULL;
marks[2] = NULL;
}
I use both pointer arrays in this function...
void Students::storeValues(int num)
{
this->num = num;
studentsAge = new int[num];
for(int i=0; i<num; i++)
{
studentsAge[i] = i;
marks[i] = new double[num]
}
}
This is my destructor...
Students::Students()
{
for(int i=0; i<num; i++)
{
delete[] marks[i];
delete[] studentAge[i];
}
delete[] marks;
delete[] studentAge
}
I am not sure if my constructor and destructor are right and I can suspect a memory leak somewhere. I am not too good with pointers, but I would appreciate it if someone could tell me where I am going wrong

Answer 1

It's a better design to keep each student together:
struct Student
{
int marks[2];
int age;
};
Then store a container of students:
struct Students
{
std::vector<Student> students;
void storeValues(int num);
}
Your function would look like:
void Students::storeValues(int num)
{
students.resize(num, Student()); // zero-initialized students!
for(int i=0; i<num; i++)
students[i].age = i;
}
This way you do not need to write any destructors, or any other functions in the Rule of Five, so you reduce the opportunity to make errors and avoid wasting time writing boilerplate code.

Answer 2

There's no reason to use your 2 element array of marks. make it easy on yourself and change it to 2 double*'s marks0 and marks1.
double* marks0;
double* marks1;
However if you want to continue on the current path, first you need to initialize marks correctly:
Students::Students()
{
num = 0;
studentsAge = NULL;
marks[0] = NULL; //clear the pointer to the first array of marks
marks[1] = NULL; //clear the pointer to the second array of marks
}
Now you need to create the marks arrays correctly:
void Students::storeValues(int num)
{
this->num = num;
studentsAge = new int[num];
marks[0] = new double[num];
marks[1] = new double[num];
for(int i=0; i<num; i++)
{
studentsAge[i] = i; //what is this doing? each student's age is the same as his/her index?
marks[0][i] = 0; //initialize the first mark for student i
marks[1][i] = 0; //initialize the second mark for student i
}
}
Finally you need to destroy the arrays correctly:
Students::~Students()
{
delete[] marks[0];
delete[] marks[1];
delete[] studentsAge;
}

Answer 3

I am guessing your Students class looks a bit like this as far as your main fields are concerned:
class Students
{
private:
static const int maxNumberMarks = 2; //the maximum number of marks that can be stored per student
int numStudents; // the count of the number of students
int* studentsAge; // an array of each students ages
double* marks[maxNumberMarks]; // an array of arrays to store each student mark
}
In which case your default constructor is almost right. You just needed to initialise your marks array correctly.
Students::Students()
{
num = 0;
studentsAge = NULL;
for( int markIndex = 0; markIndex < maxNumberMarks; ++markIndex )
{
marks[markIndex ] = NULL;
}
}
Your initialisation function is a bit more confused.
First off I would rename the input num arg to something like numStudents so as to not get confused with the member variable of the same name.
Secondly you need to separate the allocation of your arrays from initialising them
void Students::storeValues(int numStudents )
{
this->num = numStudents ; //store off how many students we are handling.
//allocate 3 storage arrays for each student. The age array and 2 mark arrays
studentsAge = new int[numStudents ];
for( int markIndex =0; markIndex < maxNumberMarks; ++markIndex)
{
marks[markIndex] = new double[numStudents];
}
//now init the arrays to something
for(int studentIndex=0; studentIndex < numStudents ; studentIndex++)
{
studentsAge[studentIndex] = studentIndex;
for( int markIndex =0; markIndex < maxNumberMarks; ++markIndex)
{
marks[markIndex][studentIndex] = 0.0; //zero seems a reasonable initial value.
}
}
}
Finally to get the destructor you just need to mirror the code that allocated the arrays.
~Students()
{
//delete the marks arrays
for( int markIndex =0; markIndex < maxNumberMarks; ++markIndex)
{
delete[] marks[markIndex];
marks[markIndex] = NULL;
}
//delete the ages array
delete[] studentsAge;
studentsAge = NULL;
}
As your code grows it likely you will want to store different data for each student I would recommend creating a Student class to help simplify everything.
class Student
{
private:
static const int maxNumberMarks = 2; //the maximum number of marks that can be stored per student
int age; //the age of the student
double marks[maxNumberMarks];
}
Assuming you flesh out the Student array with appropriate Default constructor this simplifies all the many allocations to just one place in the Students class
Students
{
Student* studentsArray; //dynamically allocated array of student info
int numStudents;
}
void Students::storeValues(int numStudents )
{
this->num = numStudents ;
studentsArray = new Student[numStduents];
}
~Students()
{
delete[] studentsArray;
studentsArray = NULL;
}
And if you use the std::vector in place of the allocated array you don't even need to worry about allocating and freeing that.

Answer 4

Short answer:
You need to write the following:
Students::Students()
{
num = 0;
studentsAge = NULL;
marks[0] = NULL;
marks[1] = NULL;
}
void Students::storeValues(int num)
{
this->num = num;
studentsAge = new int[num];
marks[0] = new int[num];
marks[1] = new int[num];
for(int i=0; i<num; i++)
{
studentsAge[i] = i; // this is where you give each student an age, are you sure you want to use i?
// here you can put grade assignments as follows:
marks[0][i] = val1; // first mark for student i
marks[1][i] = val2; // second mark for student i
}
}
Students::~Students()
{
delete[] marks[0];
delete[] marks[1];
delete[] studentsAge;
}
Long answer:
It seems that you need to understand what a pointer is and what an array is.
When you put double *marks[2] in the class declaration, it'll reserve an array of size 2 of double
pointers attached to each instance of the class. You don't need to put the [2] in the constructor.
A pointer is a variable holding the first address of a block of reserved addresses in memory. This means when you assign to a pointer, you need to give it a memory address. To write a value to the address stored in a pointer, you use the * character before the variable.
int num = 2;
int* p;
p = &num; // p will hold the address of num. Any changes to p's value will be reflected in num
p = new int; // p is assigned a new address
*p = num; // the address that p points to will hold 2 (the value in num), but if that value is changed, num will still hold 2
If you wanted to assign an array to p, you would use the new keyword. This will allocate memory
for your program to use. Don't forget to deallocate it.
size = 10;
p = new int[size];
Now you can reference the values in p by treating it as an array or pointer arithmetic,
which I won't go into now.
p[0] = 1; // the first
p[5] = 56;
The difference between a pointer and an array is array allocation and deallocation is handled by the
compiler and needs to have a fixed size at compile time. Pointer allocation and deallocation is handled by the user and its size is defined at runtime.