Access Violation error on VC++ - c++

Question

Why am i getting "Access violation error reading " on the following program:
The error is on the while loop to read the file.
#include <iostream>
class fileReader
{
public:
FILE *fp;
char** lines;
fileReader()
{
fp = NULL;
}
fileReader(const char* path)
{
int i=0;
fp = fopen(path,"r");
while ( fgets(lines[i], 100, fp) )
i++;
}
};
int main(int argv, char** argc)
{
const char* path = "D:\\PS4263-2.txt";
fileReader *p = new fileReader(path);
for (int i=0; i<2; i++)
std::cout<<p->lines[i];
return 0;
}
EDIT
As mentioned by the answers I changed my code to (below), but I am still getting the same error.
#include <iostream>
class fileReader
{
public:
FILE *fp;
char** lines;
fileReader()
{
fp = NULL;
}
fileReader(char* path)
{
int j=0;
fp = fopen(path,"r");
if (fp == NULL)
return;
else
{
lines = (char**) malloc(sizeof(char *)*56000);
for (int i=0; i<56000; i++)
lines[i] = (char*)malloc(sizeof(char)*1440);
while ( fgets(lines[j], 1440, fp) )
j++;
fclose(fp);
}
}
};
int main(int argv, char** argc)
{
char* path = "D:\\testfile.txt";
fileReader *p = new fileReader(path);
for (int i=0; i<2; i++)
std::cout<<p->lines[i];
return 0;
}

Answer 1

There are a number of problems with this code. But primarily, the problem is that you're writing some evil C/C++ hybrid. Pick one of the two languages, and use that.
Here's a revised version of your code:
#include <iostream>
class fileReader
{
public:
FILE *fp;
char** lines;
fileReader() : fp(NULL) // initialization of members happens here
{
//fp = NULL; // anything here happens *after* initialization
lines = new char*[100]; // let's just assume max 100 lines. We have to allocate space for them
for (int i = 0; i < 100; ++i) {
lines[i] = new char[100]; // allocate space for the contents of each individual line
}
}
fileReader(const char* path)
{
lines = new char*[100]; // let's just assume max 100 lines. We have to allocate space for them
for (int i = 0; i < 100; ++i) {
lines[i] = new char[100]; // allocate space for the contents of each individual line
}
int i=0;
fp = fopen(path,"r");
while ( fgets(lines[i], 100, fp) )
i++;
}
~fileReader() {
// deallocate and close our members:
fclose(fp);
for (int i = 0; i < 100; ++i) {
delete[] lines[i]; // delete the contents of each line
}
delete[] lines; // delete the lines array
}
};
int main(int argv, char** argc)
{
const char* path = "D:\\PS4263-2.txt";
fileReader p(path); // don't use new unless you really really have to
for (int i=0; i<2; i++)
std::cout<<p.lines[i];
return 0;
}
Now at least it works, if each line contains less than 100 characters and there are fewer than 100 lines and the file exists and a dozen other conditions that we really should protect against. In particular, we spend a lot of effort on memory management: allocating and deallocating space for all the line data.
But we can do a lot better with just a few changes, if we actually start writing C++.
#include <iostream> // we need this for the standard streams (cout)
#include <fstream> // we need proper C++ file streams too
#include <string> // C++ has strings. Don't waste your time on char pointers
#include <vector> // C++ has a dynamic array class. Don't use pointers as ad-hoc arrays
class fileReader
{
public:
// FILE* fp; // no point in making this a class member, when it's only used in one function
std::vector<std::string> lines; // use a vector of strings. Much easier to manage
fileReader() // vectors are automatically initialized, no need to do anything
{
}
fileReader(std::string path)
{
std::ifstream fp(path); // create an input file stream
std::string result; // store the contents of the current line here
while (std::getline(fp, result)) {
lines.push_back(result); // append the resulting line to the end of the vector
}
}
};
int main(int argv, char** argc)
{
std::string path = "blah.txt";
fileReader p(path); // don't use new unless you absolutely have to
for (int i=0; i<2; i++)
std::cout<<p.lines[i];
return 0;
}
Note that we no longer have to manage our array memory. Vectors and strings automatically clean up after themselves when they go out of scope. And because we no longer use new to allocate the fileReader, it automatically gets deleted when it goes out of scope. This effectively starts a chain reaction where its members start cleaning up after themselves: the file stream closes, the vectors deallocates its memory after asking its stored strings to clean up and shut down. And the entire program folds over and closes down without us having to write a single line of code to handle it.

Answer 2

char** lines;
Was never allocated any memory!
To be able to do anything meaningful with it, You need to allocate it enough memory to hold the contents that you intend to hold in it.
Also on a sidenote,
You never deallocate the dynamic memory allocated to p by calling delete p; once done with its usage, this gives you an Undefined Behavior.
You never check for return value of standard library functions, You should always do so.

Answer 3

There are many problems in your codes:
char** lines has not been allocated. You need to allocate lines and
lines[i].
You never check if the file is really open. Check fp before using it.
You forgot to close the file pointer at the end. Call fclose(fp).
EDIT :
You are not deallocating lines, lines[i] and p. Be careful, you must use free() for lines and lines[i] and delete for p.