Dynamic memory Points in C++

Question

I am trying to write code in C++ that reads from a file, a sequence of points, stores it in a dynamic array and then prints back.

This is the specification I've been given:

"We want to take advantage of the fact that we can use dynamic memory, thus instead of allocating at beginning an amount of memory large enough according to our estimations, we implement the following algorithm:

Initially, very little memory is allocated.

At each iteration of the loop (reading from the file and storing into the dynamic array) we keep track of:

• The array maximum size (the allocated memory).
• The number of elements in the array.

When, because of a new insertion, the number of elements would become greater than the array maximum size, memory reallocation needs to take place as follows:

• Allocate another dynamic array with a greater maximum size.
• Copy all the elements from the previous array to the new one.
• Deallocate the memory area allocated for the previous array.
• Get the pointer to the previous array to point to the new one.
• Add the new item at the end of the array. This is where my problem is.

From my code below, I think everything else is fine but the last requirement, which is to add the new item at the end of the array.

The code works fine when the array Max_Size exceeds file's number of elements, but when I try extending the num_elements, the result is that the extra digits in the file are just saved as zeros

.

Also to add, the assignment doesn't allow use of vectors just yet. Sorry I forgot to mention this, I'm new to stackoverflow and somewhat to programming.

Any help please

#include <iostream>
#include <fstream>
#include <cstdlib>
using namespace std;

struct point {  
    double x;
    double y;
};

int main () {

    ifstream inputfile;

    inputfile.open("datainput.txt");

    if(!inputfile.is_open()){
    cout << "could not open file" << endl;
        exit(EXIT_FAILURE);
    }

    //initially very little memory is allocated
    int Max_Size = 10;
    int num_elements = 0;
    point *pp = new point[Max_Size];


    //read from file and store in dynamic array
    for (int i = 0; !inputfile.eof(); i++) {
            inputfile >> pp[i].x >> pp[i].y;
            num_elements++;                 //keep track of number of elements in array
        }


    //detecting when number of elements exeeds max size due to new insertion:
    if (num_elements > Max_Size){

        // allocate another dynamic array with a greater maximum size
        Max_Size *= 2;              // Max_Size = 2*Max_Size to double max size whenever there's memory problem
        point *pp2 = new point[Max_Size];

        //copy all elements from previous array to new one
        for (int j=0; j<(Max_Size/2); j++) {
            pp2[j].x = pp[j].x ;
            pp2[j].y = pp[j].y;
        }


        //deallocate memory area allocated for previous array
        delete [] pp;

        //get pointer to previous array to point to the new one
        pp = pp2;





 **//add new item at end of the array
        for (int k = ((Max_Size/2)-1); k<num_elements; k++) {
                     inputfile.seekg(k, ios::beg) >> pp2[k].x;
                     inputfile.seekg(k, ios::beg) >> pp2[k].y;

                }**


        //print out dynamic array values
        for (int l = 0; l<num_elements; l++) {
            cout << pp2[l].x << ",";    
            cout << pp2[l].y << endl; 
        }

        //delete dynamic array
        delete [] pp2;
    }

    else {
        //print out dynamic array values
        for (int m = 0; m<num_elements; m++) {
            cout << pp[m].x << ","; 
            cout << pp[m].y << endl; 
        }

        //delete dynamic array
        delete [] pp;
    }   

    cout <<"Number of elements = " << num_elements <<endl;




    //close file
    inputfile.close();

    return 0;
}

Answer 1

Others have already pointed out std::vector. Here's roughly how code using it could look:

#include <vector>
#include <iostream>

struct point {
    double x;
    double y;

    friend std::istream &operator>>(std::istream &is, point &p) { 
        return is >> p.x >> p.y;
    }

    friend std::ostream &operator<<(std::ostream &os, point const &p) { 
        return os << p.x << "," << p.y;
    }
};

int main() { 
    // open the file of data
    std::ifstream in("datainput.txt");

    // initialize the vector from the file of data:
    std::vector<point> p {
        std::istream_iterator<point>(in),
        std::istream_iterator<point>() };

    // print out the data:
    std::copy(p.begin(), p.end(), std::ostream_iterator<point>(std::cout, "\n"));
}

On top of being a lot shorter and simpler than the code you posted, getting this to work is likely to be a lot simpler and (as icing on the cake) it will almost certainly run faster¹ (especially if you have a lot of data).

---

^{1. In fairness, I feel obliged to point out that the big difference in speed will mostly come from using \n instead of endl to terminate each line. This avoids flushing the file buffer as each line is written, which can easily give an order of magnitude speed improvement. See also: https://stackoverflow.com/a/1926432/179910}

Answer 2

The program logic is flawed. You run the loop until EOF but you don't check to see if you have exeeded your array size. I would add an if statement inside of the first loop to check if you have passed the Max_Size. I would also write a function to reallocate the memory so you can simply call that function inside of your first loop.

Also you have problems with your memory allocation. You should do like this:

point temp = pp;
pp = new Point[...];
// Copy the contents of temp into pp
delete temp;

You need to set your pointer to the old array first so you don't lose it. Then after you have copied the contents of you old array into the new array, you can then delete the old array.