复制构造函数问题 C++：“0xC0000005：访问冲突写入位置 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)