BigInt C++ and proper copy constructor?

Question

I'm trying to implement BigInt for C++ and have run into a problem with copy constructors. You can see I commented out my original code for the copy constructor which was just *this = orig;. But I have found that you need to use pointer instead to do this. I'm not entirely sure how this entirely works however and currently the code doesn't properly make a copy constructor.

-BigIntVector is a custom vector class. Compare to STL Vector.

BigInt.h:

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

    BigIntVector* ptr; //pointer to copy?

public:
    // copy constructor
    BigInt(BigInt const& orig);

    // constructor where data value is passed as a long
    BigInt(long num);

    // destructor
    ~BigInt();

    // binary '+' operator
    BigInt operator+(BigInt const& other) const;

    // unary '+' operator
    BigInt operator+() const;

    //more operator unloading functions

Here is my current implementation of the constructors in BigInt.cpp:

// copy constructor
BigInt::BigInt(BigInt const& orig) {
    ptr = new BigIntVector;
    *ptr = *orig.ptr;
    //*this = orig;
}

// constructor where operand is a long
BigInt::BigInt(long num) {
    //this->data = num;

    ptr = new BigIntVector;

    base = 10;

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

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

    //resize vector to match size of long
    bigIntVector = BigIntVector(sizeOfLong);

    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;
}

//code for overloading operators for BigInt below

Code for BigIntVector constructors:

BigIntVector::BigIntVector(long initialSize)
{
    vectorTotalSize = initialSize;
    vectorIncrementSize = initialSize;

    vectorArray = (long *)malloc(initialSize*sizeof(long));
    for (long i = 0; i < initialSize; i++) vectorArray[i] = 0;

    nextValue = 0;
}

Answer 1

Well. I don't know what BigIntVector* ptr; //pointer to copy? is for so I am assuming it is a mistake. Your code should look like this:

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

public:
    // constructor where data value is passed as a long
    BigInt(long num = 0);

    BigInt &operator+=(BigInt const& other);

    // Other accessors...
};

inline BigInt operator+(BigInt a, BigInt const &b) { a += b; return a; }

The main principle here is the Rule of Zero. You design your class so that the default-generated function does the correct thing for: copy-constructor, move-constructor, move-assignment, copy-assignment, destructor.

Then your class definition remains simple. To achieve this goal, all data members must implement those functions correctly -- either by following the Rule of Zero themself, or actually having the functions.

The built-in types all follow the rule, and I am assuming that BigIntVector follows rule of 0,3, or 5. (If not, fix it so that it does!)

Other changes I made are:

• It is good style for non-mutating operators to be non-member functions. If you find yourself able to put const on a member operator it's a good sign that it should be a non-member. For more on this topic see this thread.
• Comments should say something additional to what the code says. Putting a comment "destructor" over the destructor, or "binary + operator" over the binary + operator just clutters your screen for no reason.

In your long constructor, int tempNum = num; should be long tempNum = num;; and you should initialize skip.

Answer 2

In the real world (outside of homework), a BigInt class should not need an explicit copy constructor. The memory allocation should be delegated to a separate class -- most likely std::vector. If you need a pointer as a class member (unlikely in this case), managing that with std::shared_ptr eliminates the need for a copy constructor.

Here's an earlier post of mine that address your misconceptions about the use of new in C++. The references to C# in that description apply equally well to Java: Is garbage collection automatic in standard C++?

Regarding a question in the comments: "what is the syntax for full members". The comment suggesting that was just saying don't declare the element as a pointer (just leave out the *). To summarize, for this class:

• You don't need a pointer
• You don't need a copy constructor
• You don't need to use the new keyword

---

In this case, the problem lies in your BigIntVector class. Since that is the one that allocates memory and manages a pointer, that is the one that would require a copy constructor. If this is a homework assignment, I suggest applying the rule of three to your implementation of BigIntVector. You will need all of the following:

• a copy constructor, which copies the memory
• an assignment operator, which also copies the memory
• a destructor, which releases the memory

If it isn't homework, I suggest replacing BigIntVector with std::vector.

---

It is a bad idea to declare a copy constructor for a non-trivial class because you would generally need to copy every member explicitly (or they will be default-initialized rather than copied) -- better to let the compiler do it for you to avoid mistakes.

If you must have one for this assignment, the correct form would be something like this:

BigInt::BigInt(BigInt const& orig)
 : bigIntVector(orig.bigIntVector)
 , isPositive(orig.isPositive)
 , base(orig.base)
 , skip(orig.skip)
{
// empty body
}

---

The canonical form of forwarding arithmetic operators to compound assignment operators is some variation of:

T& T::operator += ( T const & b )
{
  ...class-specific math logic that modifies the object...
  return (*this);
}

T operator + ( T const & a, T const & b )
{
  T temp(a); // create a temporary copy of 'a' rather than modifying it
  return temp += b;
}