I am attempting to subtract two int arrays, stored as class members, using an overloaded - operator, but I'm getting some peculiar output when I run tests. The overload definition is

Number& Number :: operator-(const Number& NumberObject)
{   
    for (int count = 0; count < NumberSize; count ++)
    {
        Value[count] -= NumberObject.Value[count];
    }
    return *this;
}

Whenever I run tests on this, NumberObject.Value[count] always seems to be returning a zero value. Can anyone see where I'm going wrong with this?

The line in main() where this subtraction is being carried out is

cout << "The difference is: " << ArrayOfNumbers[0] - ArrayOfNumbers[1] << endl;

ArrayOfNumbers contains two Number objects.

The class declaration is

#include <iostream>
using namespace std;

class Number
{
private:
    int Value[50];
    int NumberSize;
public:
    Number(); // Default constructor
    Number(const Number&); // Copy constructor
        Number(int, int); // Non-default constructor
        void SetMemberValues(int, int); // Manually set member values
        int GetNumberSize() const; // Return NumberSize member
        int GetValue() const; // Return Value[] member
        Number& operator-=(const Number&);
};

inline Number operator-(Number Lhs, const Number& Rhs);
ostream& operator<<(ostream&, const Number&);

The full class definition is as follows:

 #include <iostream>
#include "../headers/number.h"
using namespace std;

// Default constructor
Number :: Number()
{}

// Copy constructor
Number :: Number(const Number& NumberObject)
{
    int Temp[NumberSize];
    NumberSize = NumberObject.GetNumberSize();
    for (int count = 0; count < NumberObject.GetNumberSize(); count ++)
    {
        Temp[count] = Value[count] - NumberObject.GetValue();
    }
}

// Manually set member values
void Number :: SetMemberValues(int NewNumberValue, int NewNumberSize)
{
    NumberSize = NewNumberSize;
    for (int count = NewNumberSize - 1; count >= 0; count --)
    {
        Value[count] = NewNumberValue % 10;
        NewNumberValue = NewNumberValue / 10;
    }
}

// Non-default constructor
Number :: Number(int NumberValue, int NewNumberSize)
{
    NumberSize = NewNumberSize;
    for (int count = NewNumberSize - 1; count >= 0; count --)
    {
        Value[count] = NumberValue % 10;
        NumberValue = NumberValue / 10;
    }
}

// Return the NumberSize member
int Number :: GetNumberSize() const
{
    return NumberSize;
}

// Return the Value[] member
int Number :: GetValue() const
{
    int ResultSoFar;
    for (int count2 = 0; count2 < NumberSize; count2 ++)
    {
        ResultSoFar = ResultSoFar * 10 + Value[count2];
    }
    return ResultSoFar;
}

Number& operator-=(const Number& Rhs)
{
    for (int count = 0; count < NumberSize; count ++)
    {
        Value[count] -= Rhs.Value[count];
    }
    return *this;
}

inline Number operator-(Number Lhs, const Number& Rhs)
{
    Lhs -= Rhs;
    return Lhs;
}

// Overloaded output operator
ostream& operator<<(ostream& OutputStream, const Number& NumberObject)
{
    OutputStream << NumberObject.GetValue();
    return OutputStream;
}