pointers - Copy Constructor Issue C++: "0xC0000005: Access violation writing location 0x00000000."

Question

I'm having some trouble getting my copy constructor to work in my BigInt class I'm working on.

In BigIntVector.cpp in the copy constructor, the lines:

    for (int i = 0; i < vectorSize; i++) {
        vectorArray[i] = orig.vectorArray[i];
    }

causes the exception 0xC0000005: Access violation writing location 0x00000000. Any help figuring out why would be appreciated. Thank you.

In BigInt.cpp:

// copy constructor
BigInt::BigInt(BigInt const& orig) 
 : isPositive(orig.isPositive)
, base(orig.base)
, skip(orig.skip) 
{
    this->bigIntVector = new BigIntVector(*orig.bigIntVector);
}

// constructor where operand is a long
BigInt::BigInt(long num) {
    base = 10;

    long sizeOfLong = 0; //holds size of num
    long tempNum = num;

    //get size of num
    if (tempNum == 0) {
        sizeOfLong = 1;
    }
    while (tempNum != 0)
    {
        tempNum /= 10;
        ++sizeOfLong;
    }

    //resize vector to match size of long
    this->bigIntVector = new BigIntVector(sizeOfLong);

    //cout << "sizeVec: " << bigIntVector.getSize() << endl;

    if (num < 0) {
        isPositive = false;
        num *= -1;
    }
    else {
        isPositive = true;
    }
    long pushedNum;
    //cout << "num: " << num << endl;
    for (int i = sizeOfLong - 1; i >= 0; --i) {
        pushedNum = (long)(num%base);
        bigIntVector->setElementAt(i, pushedNum);
        num /= base;
    }
}

// destructor
BigInt::~BigInt() {
    delete[] this->bigIntVector;
}

// binary addition
BigInt BigInt::operator+(BigInt const& other) const {

    BigInt temp(*this);
    return temp += other;
}

//more code...

My BigInt.h:

class BigInt {
private:
    BigIntVector *bigIntVector;
    bool isPositive;
    int base;
    unsigned int skip;

public:
    BigInt(BigInt const& orig);
    BigInt(long num);
    ~BigInt();
    BigInt operator+(BigInt const& other) const;
    BigInt operator+() const;
    BigInt operator++();
    BigInt operator++(int dummy);
    BigInt operator+=(BigInt const& other);
    BigInt BigInt::operator-(BigInt const& other) const;
    BigInt BigInt::operator-=(BigInt const& other);
    bool operator==(BigInt const& other) const;
    friend std::ostream & operator<<(std::ostream& os, BigInt& num);
};
inline BigInt operator+(long num, BigInt const& val) {
    return val + num;
}
inline bool operator==(long num, BigInt const& val) {
    return val == num;
}

My BigIntVector is a custom Vector class. Compared to STL Vector.

The constructors in BigIntVector.cpp:

// copy constructor
BigIntVector::BigIntVector(BigIntVector const& orig)
    : vectorSize(orig.vectorSize)
{
    for (int i = 0; i < vectorSize; i++) {
        vectorArray[i] = orig.vectorArray[i];
    }
}

BigIntVector::~BigIntVector() {
    delete[] vectorArray;
}

//default constructor
BigIntVector::BigIntVector()
{
    vectorSize = 1;

    //vectorArray = (long *)malloc(10 * sizeof(long));
    vectorArray = new long[vectorSize];
    for (long i = 0; i < vectorSize; i++) {
        vectorArray[i] = 0;
    }
}

//constructor that initializes a custom size for vector
BigIntVector::BigIntVector(long initialSize)
{
    vectorSize = initialSize;

    //vectorArray = (long *)malloc(initialSize*sizeof(long));
    vectorArray = new long[vectorSize];
    for (long i = 0; i < initialSize; i++) {
        vectorArray[i] = 0;
    }
}

//more code

main.cpp:

int main(void) {

    // object with explicit constructor from long
    BigInt num1(12);

    cout << "num1 (12): " << num1 << endl;

    // object with implicit constructor from long
    BigInt num2 = 19;

    cout << "num2 (19): " << num2 << endl;

    // binary addition BigInt+BigInt
    BigInt num3 = num1 + num2;

    cout << "num3 (31): " << num3 << endl;

    BigInt numA = 99999;

    cout << "numA (99999): " << numA << endl;

    BigInt numB = 99999;

    cout << "numB (99999): " << numB << endl;

    BigInt numC = numA + numB;

    cout << "numC (199998): " << numC << endl;

    return EXIT_SUCCESS;
}

Answer 1

you are passing reference to orig. you should use 'orig.bigIntVector'

BigInt::BigInt(BigInt const& orig) 
 : isPositive(orig.isPositive)
, base(orig.base)
, skip(orig.skip) 
{
    this->bigIntVector = new BigIntVector(*(orig.bigIntVector));
}

should use *(orig.bigIntVector)