我看到代码有很多问题。让我们从你的输入函数开始。

int * input () { // This line needs to be changed
  int * input; // This is fine too
  input = new int; // error here
  cout << "Please enter a large integer: "; // This is fine
  cin >> input; // This won't work
  return input;
}

要声明一个动态数组，你需要指定数组的大小。你不指定大小。此外，你需要弄清楚你需要多大的数组（largeInteger中需要多少个数字）。为此，你需要知道用户计算的数字有多大。所以你需要在得到用户输入并找出它有多大后分配动态数组。

我建议您使用字符串来获取用户输入，这样您就可以获得输入的大小。此外，为了简化事情，我们需要在函数中创建并返回largeInteger。

这是迄今为止更正的代码：

largeInteger input () {
  int * input; // This is fine too
  cout << "Please enter a large integer: "; // This is fine
  string userInput; // Don't forget to add #include <string>
  cin >> userInput;
  input = new int[userInput.length()]
  return input;
}

userInput. long（）调用字符串对象的长度函数，该函数返回字符串的大小。现在我们必须遍历字符串中的每个字符并将它们转换为整数以将它们添加到输入动态数组中。

我们可以使用for循环来做到这一点。让我们同时创建largeInteger。我们还需要向后接受输入，因为以后会更容易。所以更正后的输入函数是：

largeInteger input () {
  int * input; // This is fine
  cout << "Please enter a large integer: "; // This is fine too
  string userInput; // Don't forget to add #include <string>
  cin >> userInput;
  input = new int[userInput.length()]
  for(int i = userInput.length()-1; i >= 0 ; i--)
  {
    int intValue = userInput[i] - '0'; // This converts the char inside the string to an int
    input[i] = intValue;
  }
  largeInteger big = largeInteger(input, userInput.length()); // This line only makes sense with the changes detailed later in the post.
  return input;
}

好的，现在这部分已经完成，是时候继续类定义了。

class largeInteger {
  public:             
         largeInteger = input(); // error here

         void print(int largeInteger); // needs to be redeclared

         void add(); // Needs to be redeclared
};

为了清楚起见，我已经删除了您的注释。因此，创建某个类的对象的方式是通过它的构造函数，因此让我们将其添加并删除

largeInteger = input();

构造函数与类同名，是一个函数。类还包含数据和函数，因此我们需要添加一个数据成员来包含动态数组。我们还希望我们的构造函数将动态数组作为函数，以便它可以初始化它的数据成员。我们还需要一些后面的函数的动态数组大小，因此我们也将其添加为数据成员。以下是更正后的类定义现在的样子：

class largeInteger {
  public:             
         largeInteger(int* array, int newSize){
           dataMember = array;
           size = newSize;
         }

         void print(int largeInteger); // needs to be redeclared            
         void add(); // Needs to be redeclared            
         int* dataMember; // The new data member that we added
         int size;
};

现在让我们研究打印函数。打印函数不需要任何参数，因为它可以访问数据成员。我们将通过与创建数据成员相同的方式打印数据成员的方式，通过for循环。您可以在类定义之外定义一个方法（类中函数的另一个名称），但您需要说明它来自哪里，这是您的写法：

void largeInteger::print(){
  for(int i = size; i >=0; i--){ // Remember, we need to print it backwards of backwards, so forwards
    cout << dataMember[i]; 
  }
}

这里，size和data会员都是我们上面声明的类的数据成员。我们可以访问它们，因为我们将print声明为largeInteger的方法。

现在让我们看看add函数。

我们需要声明它，以便它接受另一个largeInteger作为参数，否则它不会添加任何其他东西。它还需要返回一个largeInteger，否则将它们相加不会做任何事情。所以让我们重写它来编写largeInterger类定义的最终版本。

class largeInteger {
  public:             
         largeInteger(int* array, int newSize){
           dataMember = array;
           size = newSize;
         }

         void print(int largeInteger); // needs to be redeclared            
         largeInteger add(largeInteger rhs); // rhs means right-hand-side           
         int* dataMember; // The new data member that we added
         int size;
};

让我们看看它的实现。这是最复杂的功能，但它是可能的。我们需要一个接一个地添加数字，我们需要将结转添加到下一个数字。此外，由于我们向后获取了数字，因此更容易将它们相加。以下是一个实现：

largeInteger largeInteger::add(largeInteger rhs){
  int* sum;
  if (size >= rhs.size){
    sum = new int[size+1]; // size+1 is the maximum size the large int could get in this situation
    int carryover = 0;
    // Add the two numbers
    for(int i = 0; i < rhs.size; i++){
        int partialSum = dataMember[i] + rhs.dataMember[i] + carryover;
        if( partialSum >= 10){
          carryover = 1;
          partialSum -= 10;
        }
        else{
          carryover = 0;
        }
        sum[rhs.size - i - 1] = partialSum; // remember, we have to enter the numbers backwards
      }
    // Fill in the remaining numbers
    for(int i = size-1; i >= rhs.size; i--){
      sum[i] = dataMember[i];
    }
    return largeInteger(sum,size+1);
  }
  else{
    sum = new int[rhs.size+1]; // rhs.size+1 is the maximum size the large int could get in this situation
    int carryover = 0;
    // Add the two numbers
    for(int i = 0; i < size; i++){
        int partialSum = dataMember[i] + rhs.dataMember[i] + carryover;
        if( partialSum >= 10){
          carryover = 1;
          partialSum -= 10;
        }
        else{
          carryover = 0;
        }
        sum[size - i - 1] = partialSum; // remember, we have to enter the numbers backwards
      }
    // Fill in the remaining numbers
    for(int i = rhs.size-1; i >= size; i--){
      sum[i] = rhs.dataMember[i];
    }
    return largeInteger(sum,rhs.size+1);
  }

}

现在我重新阅读了代码，这可能是在没有将数字向后存储的情况下完成的，但是我不想改变它。所以干得好。

但是，正如其他人所说，你真的应该读一本C书，因为基本上你写的东西都不是有效的C，或者真的做了你想做的事。