Question

说明是：

int变量可以处理的最大值是2147483647.创建一个类名为largeInteger，它使用动态数组来存储任意数量的整数数字。提供一个input（）函数来从cin中获取一个大整数的输入。提供print（）函数来显示cout的大整数。提供一个add（）函数来添加两个大整数并将总和作为一个返回大整数

到目前为止，我在函数之间输入和传递值时遇到了问题，因为我对c ++语法的掌握非常有限。任何帮助将不胜感激。这是我目前的代码，充满了问题。

#include <cstdlib>
#include <iostream>

using namespace std;

class largeInteger {
  public:
         // Takes input of a large integer from cin
         largeInteger = input();
         // displays large integer to cout
         void print(int largeInteger);
         // adds two large integers and returns the sum as a large integer
         void add();
};

int * input () {
 int * input;
 input = new int;
 cout << "Please enter a large integer: ";
 cin >> input;
 return input;
}

void print (largeInteger) {
 cout << "The entered large integer is: " << largeInteger;
}

void add (largeInteger) {
 int * sum;
 sum = new int;
 sum = largeInteger + largeInteger;
 cout << "The sum of the two large integers is: " << largeInteger;
 delete sum;
}

int main(int argc, char *argv[]) {
int * largeInteger;
largeInteger = new int;
system("PAUSE");
delete largeInteger;
return EXIT_SUCCESS;
}

Answer 1

我可以看到代码有很多问题。让我们从您的输入功能开始。

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.length（）调用字符串对象的length函数，该函数返回字符串的大小。现在我们必须遍历字符串中的每个字符并将它们转换为整数，以将它们添加到输入动态数组中。

我们可以使用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和dataMember都是我们上面声明的类的数据成员。我们可以访问它们，因为我们将print声明为largeInteger的方法。

现在让我们来看看添加功能。

我们需要声明它，以便它需要另一个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 ++，或者是你真正做到的。

使用动态数组存储大整数

1 个答案: