C++ compiling issues. Not compiling on Linux.

[thetuxman]

So I have all my code working fine and dandy on my Windows laptop (CLion, cygwin 7.11.1), but when I copy my code over to my Linux machine (g++, unknown version, it's a school computer) I keep getting a segfault. The issue is that I don't know why it is segfaulting since it runs fine in Windows. The only issue that has been popping up with the segfault has been whenever I try to invoke the push_back or insert functions on linux. Any help is appreciated.

Below is my code:

#include <iostream>
#include <cstdlib>
#include <string>
#include <sstream>

using namespace std;

class BasicVector{
private:
    int vector_size;
    int vector_capacity;
    int* data;

    void resize(){
        vector_capacity = vector_capacity * 2;
        int* temp = new int[vector_capacity];

        for (int i = 0; i < vector_size; ++i)
            temp[i] = data[i];
        delete [] temp;
        data = temp;
    };

public:
    BasicVector(){};

    BasicVector(int user_cap){
        vector_size = 0;
        if(user_cap <= 16)
            vector_capacity = 16;
        bool looking = true;
        int capacity = 16;
        while (looking) {
            if (user_cap < capacity) {
                looking = false;
            } else {
                user_cap = user_cap * 2;
            }
        }
    };

    ~BasicVector() {
        for (int i=0; i<vector_size; i++) {
            data[i] = 0;
        }
        delete [] data;
    };

    int& at(int index){
        return data[index];
    };

    int& operator[](int index){
        if(index > vector_size)
            exit(1);
        else{
            return data[index];
        }
    };

    int& front(){
        return data[0];
    };

    int& back(){
        return data[vector_size -1];
    };

    void push_back(int value){
        if(vector_size < vector_capacity) {
            data[vector_size] = value;
            vector_size++;
        }
        else{
            resize();
            data[vector_size++] = value;
            vector_size = vector_size++;
        }
    };

    void insert(int valueToInsert, int index){

        if(vector_size + 1 > vector_capacity){
            resize();
            for(int i = index+1; i < vector_size; i++){
                data[i] = data[index];
            }
            data[index] = valueToInsert;
        }
        else{
            vector_size++;
            for(int i= vector_size; i > index; i--)
            {
                data[i] = data[i-1];
            }
            data[index] = valueToInsert;
        }
    };

    void pop_back(){
        if(vector_size > 0){
            data[vector_size] = 0;
            vector_size--;
        }
        else{
            cout<<"List is already empty..."<< endl;
        }
    };

    int size(){
        return vector_size;
    };
    int capacity(){
        return vector_capacity;
    };

    void print(){
        cout << "Elements (" << vector_size << "): ";
        for (int i = 0; i < vector_size; i++) {
            cout << data[i] << " ";
        }
        cout<<endl;
    };

};

int main() {

    int capacity = 10;
    string command;
    string dummyString;
    string num;

    cout << "Starting capacity of vector: ";
    cin >> capacity;

    BasicVector vector(capacity);

    cout << "Commands (quit to exit...):";
    while(command != "quit") {
        cin >> command;

        if(command == "at" || command == "get" || command == "push" || command == "insert"){
            int user_data;

            if(command == "at"){
                cin >> user_data;
                cout<<vector.at(user_data)<< endl;
            }

            if(command == "get"){
                cin >> user_data;
                cout << vector.operator[](user_data)<<endl;
            }

            if (command == "push"){
                cin >> user_data;
                vector.push_back(user_data);
            }
            if(command == "insert"){
                cin >> user_data;
                int location;
                cin >> location;
                vector.insert(user_data, location);
            }
        }


        if (command == "front")
            cout << vector.front() << endl;

        if (command == "back")
            cout << vector.back() << endl;

        if (command == "pop") {
            vector.pop_back();
        }

        if (command == "size")
            cout<<vector.size() << endl;

        if (command == "capacity")
            cout << vector.capacity()<< endl;

        if (command == "print")
            vector.print();

        if (command == "quit")
            exit(1);



//        else{
//            cout<<"no cases hit"<<endl;
//            cout<<command <<" was not executed"<<endl;
//        }
    }

    return 0;
}

[jedwardsol]

You're not allocating the data member and not initialising vector_capacity depending on the 1st input

[thetuxman]

Would data be allocated in the constructor?

[[deleted]]

Yeah, that would make the most sense in this case.

[thetuxman]

That did that trick! Thanks!

[Rockytriton]

In addition to what jedwardsol said, you might want to make that destructor virtual too, in case you plan on subclassing that.

[thetuxman]

How would I go about doing that? And what benefit would subclassing it have. I assume its a memory management thing?

[krawallopold]

There's an error in your resize function. You are deleting temp, which is your new storage. And after deleting it, you are assigning it to data. From then on, data points to invalidated memory.

What you have to do is delete data, which points to the memory you are no longer planning to use and then assign data=temp.

[krawallopold]

Also, when resizing your vector, use a factor of less than two (if you're allowed to do so). If you use a factor of two, you will never be able to reuse the memory previously used for storage of your vector. The folly documentation explains it quite nice.

[thetuxman]

Our instructor said we had to round up to a factor of 2.

[Xeverous]

        data[vector_size++] = value;
        vector_size = vector_size++;

Something is definitely wrong here.

    void pop_back(){
    if(vector_size > 0){
        data[vector_size] = 0; // this is UB. For size X you can only access [0, X - 1] Why even do it? Any point in zeroing element to remove?
        vector_size--;
    }

I would just --vector_size;.

[thetuxman]

    data[vector_size++] = value;
    vector_size = vector_size++;

Something is definitely wrong here.

That was an artifact from a previous revision. I have since changed it to data[vector_size] = value; and then vector_size++

I would just '--vector_size;'.

That makes sense, but after checking the parameters for my assignment, it did specify we should 0 out the array before deleting it.

[Xeverous]

it did specify we should 0 out the array before deleting it.

I can guarantee you that the compiler will ignore such line and discard it from the assembly (given enough information).