Write access violation - **this** - c++

Question

I'm trying to refactor some code to use pointers and am running into a write access violation on my function calls.
I'm making these edits because my homework project requires the usage of the -> member operator as well as constructors and destructors.
One more edit: the input file worked just fine when I was formerly working without pointers, but the moment I added pointers everything broke.
Here's my code:
In main.cpp:
#include "student.h"
int main()
{
/*
TODO:
2. Implement the class such that member pointers can be used to access the members.
3. Implement pointers that point to each of the students' test scores as well as the average test score.
*/
const int numStudents = 15; // Number of students
Student * students = new Student[numStudents]; // Dynamically allocated array of Student objects
Student ** studentsPtr = &students;
// Starting file stream for studentRecords.dat
ifstream student_records("student_records.dat");
// Error checking for file loading
if (!student_records)
{
cerr << "ERROR: The record file could not be opened for reading." << endl;
exit(1);
}
// Load data from file
string current_value;
stringstream newval;
int tempID;
string tempName;
double tempTestScore;
for (int index = 0; index < numStudents; index++)
{
// Store the student ID
getline(student_records, current_value);
newval << current_value;
newval >> tempID;
studentsPtr[index]->setID(tempID);
newval.clear();
// Store the student first name
getline(student_records, current_value);
newval << current_value;
newval >> tempName;
studentsPtr[index]->setFirstName(tempName);
newval.clear();
// Store the student last name
getline(student_records, current_value);
newval << current_value;
newval >> tempName;
studentsPtr[index]->setLastName(tempName);
newval.clear();
// Add each test score.
for (int testScoreIndex = 0; testScoreIndex < numTests; testScoreIndex++)
{
getline(student_records, current_value);
newval << current_value;
newval >> tempTestScore;
studentsPtr[index]->addTestScore(tempTestScore, testScoreIndex);
newval.clear();
}
// Calculate the student's average
students[index].calculateAverage();
}
// Print all data
for (int index = 0; index < numStudents; index++)
{
studentsPtr[index]->printAll();
}
delete[] students; // Free memory pointed to by students array
students = NULL; // Clear the memory.
system("pause");
return 0;
}
In student.h:
#pragma once
#include <iostream>
#include <fstream>
#include <cstdlib>
#include <sstream>
#include <string>
#include <vector>
#include <iomanip>
using namespace std;
const int numTests = 10;
// Student class declaration
class Student
{
private:
// Student ID and name
int id;
string firstName;
string lastName;
// List of student test scores
// vector<double> testScores;
double * testScores = new double[numTests];
// Student average test score
double average;
public:
Student() // Default constructor
{
const int numTests = 10;
id = 0;
firstName = " ";
lastName = " ";
average = 0.0;
}
~Student() // Destructor
{
delete[] testScores;
}
void setID(int); // Set the student ID
void setFirstName(string); // Set the student name
void setLastName(string);
void addTestScore(double, int); // Add a test score to the vector
void calculateAverage(); // Calculate the average of all test scores
void printAll(); // Output all data to the screen for a given student
};
In student.cpp:
#include "student.h"
// setID sets the id value.
void Student::setID(int studentID)
{
id = studentID;
}
// setName sets the name value.
void Student::setFirstName(string studentFirstName)
{
firstName = studentFirstName;
}
void Student::setLastName(string studentLastName)
{
lastName = studentLastName;
}
// addTestScore adds a test score to the vector
void Student::addTestScore(double testScore, int index)
{
testScores[index] = testScore;
// testScores.push_back(testScore);
}
// calculateAverage adds every test score from the vector and divides them by the number of test scores in the list.
void Student::calculateAverage()
{
double totalScores = 0.0;
// for (double index : testScores)
for (int index = 0; index < numTests; index++)
{
totalScores += testScores[index];
}
average = totalScores / numTests;
}
// printAll prints all the data to the screen.
void Student::printAll()
{
cout << "=========================================================\n";
cout << "Student ID:\t" << id << endl;
cout << "Student Name:\t" << firstName << " " << lastName << endl;
cout << setprecision(4) << "Average:\t" << average << endl;
cout << "Test Scores: " << endl;
// Printing the test scores nicely
int scoresPerLine = 5;
for (int i = 0; i < numTests; i++)
{
cout << setprecision(4) << testScores[i] << "\t";
if ((i + 1) % scoresPerLine == 0)
{
cout << endl;
}
}
cout << endl;
cout << "=========================================================\n\n";
}
The error I'm getting is Exception thrown: write access violation. this was 0xCCCCCCCC and it throws the exception at a break point created at
void Student::setFirstName(string studentFirstName) at the line firstName = studentFirstName.
My question is: what exactly is preventing this from working? Am I doing something wrong? I dont' get any errors before I compile everything, so it looks like everything is built ok. I've also tried using a pass-by-reference on that member function, but that's also failing with the same response.

Answer 1

Am I doing something wrong?
Yes, definitely :)
Let's go through it:
Student * students = new Student[numStudents];
... the above allocates a dynamic array of 15 Student objects; so far, so good.
Student ** studentsPtr = &students;
This line is the source of the trouble. You've declared a double-pointer Student ** and initialized it to point to the address of the students pointer. This is legal C++, but note that there is only the standalone students pointer -- in particular, there is not an array of pointers-to-Student in your program anywhere. (There is an array of Student objects but that is not the same thing as an array of pointers-to-Student)
... then a bit later on, comes the actual trouble:
for (int index = 0; index < numStudents; index++)
{
[...]
studentsPtr[index]->setID(tempID); // BOOM!
Here you are trying to use studentsPtr as if it was if it was the base-address for an array of pointers-to-Student, i.e. by offsetting its location by index pointers and dereferencing that location. But it's not really pointing to an array-of-pointers, it is pointing to a single pointer (i.e. it is pointing to the variable students), so whenever index is non-zero, you are invoking undefined behavior and therefore (in your case) you get a crash.

Answer 2

Let's debug it:
Since you didn't provide a complete test case, I changed the number of students to 3 and the number of tests to 0:
student_records.dat
1
Foo
Bar
2
Foo2
Bar2
3
Foo3
Bar3
My crash occurs in setID, but that's okay. this is 0xCCCCCCCC, which is the value given to uninitialized data by MSVC in debug mode. Great, the object pointer is garbage. Where does it come from? We'll go up the call stack to see:
This brings us to the following line in the loop of main that reads the input:
studentsPtr[index]->setID(tempID);
First, let's look at the variables:
We know the object is garbage. We can verify that here. Our object is studentsPtr[index], which is shown with the same uninitialized value. We also see that studentsPtr itself points to the proper first student. Finally, the index variable has the value 1, so we're on the second student.
studentsPtr[1] has a value that MSVC provides for uninitialized memory. Why is it uninitialized? Let's go back to the declaration:
Student *students = new Student[numStudents];
Student **studentsPtr = &students;
studentsPtr is set to be a pointer to a pointer to students. The inner pointer is actually an array of students. The outer pointer, however, is one solitary Student*. When indexing it like studentsPtr[1], we go beyond the single pointer within and trample onward to a nonexistent Student*. Then we try to write to that and the program thankfully blows up early.
The solution is to get rid of the double pointer. All that's needed is a bunch of Students. One pointer is one (unrecommended way to represent an) array:
Student *students = new Student[numStudents];
...
students[index].setID(tempID);
Now since the number of elements is known at compile-time, the recommended type would be std::array (std::array<Student, numStudents> students;), which can be used with the same syntax as the above after its declaration. If the size were not known at compile-time, the recommended type would be std::vector, which also shares the same syntax to access elements.
Technically, you can fulfill the -> requirement using a std::array as well. Simply obtain a pointer to the element and then use the arrow:
(&students[index])->setID(tempID);
More likely, the requirement is still looking for the manual free store memory management that you're doing. It's also easy to fit the arrow into that:
(students + index)->setID(tempID);
If you really, really need the double pointer even though it serves no purpose, remember that your array is the inner pointer, not the outer one:
((*students) + index)->setID(tempID);
If you're thinking the arrow hinders readability in all of these scenarios, you're correct. Perhaps the instructor has something specific in mind where it does not.
What happens when the double pointer is removed?
=========================================================
Student ID: 1
Student Name: Foo Bar
Average: -nan(ind)
Test Scores:
=========================================================
=========================================================
Student ID: 2
Student Name: Foo2 Bar2
Average: -nan(ind)
Test Scores:
=========================================================
=========================================================
Student ID: 3
Student Name: Foo3 Bar3
Average: -nan(ind)
Test Scores:
=========================================================
Success. The average is meaningless because I simplified the input file by changing the number of tests to 0. Long story short, the debugger provides the tools that can get debugging jobs done. Just from the debugger, we reduced the problem to the double pointer pointing to only one thing instead of multiple things. That's a much smaller scope for a problem than the original one.