Написание класса HugeInteger
Я новичок в C++, и это то, что я должен сделать для назначения.
Создайте класс HugeInteger, который использует 40-элементный массив цифр для хранения целых чисел по 40 цифр каждое. Обеспечить функции-члены ввода, вывода, сложения и вычитания. Для сравнения объектов HugeInteger предоставьте функции isEqualTo, isNotEqualTo, isGreaterThan, isLessThan, isCreaterThanOrEqualTo и isLessThanOrEqualTo - каждая из них является функцией "предиката", которая просто возвращает истину, если связь между двумя удерживающими отношениями HugeIntegers и верна; Также предусмотрена предикатная функция isZero.
Рекомендации по дополнительным точкам: обеспечить функции-члены умножать, делить и модуль.
Мне трудно понять, как сравнивать два объекта в моем классе.
Мой код заголовка выглядит так:
#pragma once
#include <iostream>
using namespace std;
static const int MAXINTEGER = 40;
//HugeInteger Class
class HugeInteger
{
public:
HugeInteger(void); //constructor
~HugeInteger(void); //destructor
void HugeInteger::input(int[MAXINTEGER]); //input array to internal array
void HugeInteger::output(void); //write out array to screen
bool isZero(void); //test to see if it is zero
bool HugeInteger::isEqual(HugeInteger other); //test to see if the objects are equal
bool HugeInteger::isNotEqual(HugeInteger other); //test to see if the objects are not equal
bool HugeInteger::isGreaterThan(HugeInteger other); //test to see if one object is greater than the other
bool HugeInteger::isLessThan(HugeInteger other); //test to see if one object is less than the other
bool HugeInteger::isGreaterThanOrEqual(HugeInteger other); //test to see if one object is greater than or equal to the other
bool HugeInteger::isLessThanOrEqual(HugeInteger other); //test to see if one obejct is less than or equal to the other
HugeInteger HugeInteger::add(HugeInteger other); //adds two objects
HugeInteger HugeInteger::subtract(HugeInteger other); //subtract two objects
HugeInteger HugeInteger::multiply(HugeInteger other); //multiply two objects
HugeInteger HugeInteger::divide(HugeInteger other); //divide two objcts
private:
bool isPositive; //needed when we do subtraction
int hugeIntergerOne[MAXINTEGER]; //internal array
};
Мой код.cpp выглядит так:
#include "HugeInteger.h"
#include <iostream>
using namespace std;
//HugeInteger Class Functions
HugeInteger::HugeInteger(void) //constructor
{
//zero out internal array
for (int i = MAXINTEGER - 1; i >= 0; i--)
this ->hugeIntergerOne[i] = 0;
}
HugeInteger::~HugeInteger() //destructor
{
//de-allocates internal array
}
void HugeInteger::input(int newArray[MAXINTEGER])
{
//copies 'newArray' into internal array
for (int index = MAXINTEGER - 1; index >= 0; index--)
this->hugeIntergerOne[index] = newArray[index];
}
void HugeInteger::output()
{
//outputs internal array to screen
for (int index = 0; index < MAXINTEGER; index++)
cout << this->hugeIntergerOne[index] << " ";
}
bool HugeInteger::isZero(void) //test zero function
{
bool result = true;
//test whether every element of internal array is zero
for (int index = MAXINTEGER - 1; index >= 0; index--)
if (this->hugeIntergerOne[index] != 0)
result = false;
return result;
}
bool HugeInteger::isEqual(HugeInteger other) //test equal function
{
bool result = true;
for (int i = 0; i < MAXINTEGER; i++)
if (this->hugeIntergerOne[i] != other.hugeIntergerOne[i])
bool result = false;
return result;
}
bool HugeInteger::isNotEqual(HugeInteger other) //test not equal function
{
bool result = true;
for (int index = MAXINTEGER - 1; index >= 0; index--)
if (this->hugeIntergerOne[index] == other.hugeIntergerOne[index])
bool result = false;
return result;
}
bool HugeInteger::isGreaterThan(HugeInteger other) //test greater than function
{
bool result = false;
for (int index = MAXINTEGER - 1; index >= 0; index--)
if (this->hugeIntergerOne[index] > other.hugeIntergerOne[index])
bool result = true;
return result;
}
bool HugeInteger::isLessThan(HugeInteger other) //test less than function
{
bool result = false;
for (int index = MAXINTEGER - 1; index >= 0; index--)
if (this->hugeIntergerOne[index] < other.hugeIntergerOne[index])
bool result = true;
return result;
}
bool HugeInteger::isGreaterThanOrEqual(HugeInteger other) //test greater than or equal function
{
bool result = false;
for (int index = MAXINTEGER - 1; index >= 0; index--)
if (this->hugeIntergerOne[index] >= other.hugeIntergerOne[index])
bool result = true;
return result;
}
bool HugeInteger::isLessThanOrEqual(HugeInteger other) //test less than or equal function
{
bool result = false;
for (int index = MAXINTEGER - 1; index >= 0; index--)
if (this->hugeIntergerOne[index] <= other.hugeIntergerOne[index])
bool result = true;
return result;
}
HugeInteger HugeInteger::add(HugeInteger other) //adds objects
{
HugeInteger result;
for (int i = 0; i < MAXINTEGER; i++)
{
result.hugeIntergerOne[i] = this -> hugeIntergerOne[i] + other.hugeIntergerOne[i];
}
return result;
}
HugeInteger HugeInteger::subtract(HugeInteger other) //subtracts objects
{
HugeInteger result;
for (int i = 0; i < MAXINTEGER; i++)
{
result.hugeIntergerOne[i] = this->hugeIntergerOne[i] - other.hugeIntergerOne[i];
}
return result;
}
HugeInteger HugeInteger::multiply(HugeInteger other) //multiplies objects
{
HugeInteger result;
for (int i = 0; i < MAXINTEGER; i++)
{
result.hugeIntergerOne[i] = this->hugeIntergerOne[i] * other.hugeIntergerOne[i];
}
return result;
}
HugeInteger HugeInteger::divide(HugeInteger other) //divides objects
{
HugeInteger result;
for (int i = 0; i < MAXINTEGER; i++)
{
result.hugeIntergerOne[i] = this->hugeIntergerOne[i]/other.hugeIntergerOne[i];
}
return result;
}
И мой основной программный код выглядит так:
#include <iostream>
#include "HugeInteger.h"
using namespace std;
int main()
{
//create three arrays
int first[MAXINTEGER] = { 1, 2, 3, 4, 5, 6, 7, 8,
9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32,
33, 34, 35, 36, 37, 38, 39, 40 };
int second[MAXINTEGER] = { 40, 39, 38, 37, 36, 35,
34, 33, 32, 31, 30, 29, 28, 27, 26, 25, 24, 23,
22, 21, 20, 19, 18, 17, 16, 15, 14, 13, 12, 11,
10, 9, 8, 7, 6, 5, 4, 3, 2, 1 };
int zero[MAXINTEGER] = { 0 };
//create objects
HugeInteger myHugeInteger0;
HugeInteger myHugeInteger1;
HugeInteger myHugeInteger2;
HugeInteger myHugeInteger3;
//input arrays into objects
myHugeInteger1.input(first);
myHugeInteger2.input(second);
myHugeInteger0.input(zero);
//prints out the words true or false instead of a 1 or 0
cout << boolalpha << endl;
//opening statements
cout << "Welcome!\n" << endl;
cout << "We will be testing a bunch of different functions on class objects today.\n" << endl;
cout << "I have created three class objects which are 40 element arrays.\n" << endl;
system("pause");
cout << "\n" << endl;
//prints the elements in each object
cout << "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~" << endl;
cout << "My three objecs are: \n" << endl;
cout << "myHugeInteger0:\n" << endl;
myHugeInteger0.output();
cout << "\n\nmyHugeInteger1:\n" << endl;
myHugeInteger1.output();
cout << "\n\nmyHugeInteger2:\n" << endl;
myHugeInteger2.output();
cout << "\n" << endl;
//intro to check if objecs are zero
cout << "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~" << endl;
cout << "First, we will test to see if all of the elements in the arrays are equal to \nzero.\n" << endl;
system("pause");
cout << endl;
//test if the all of the object elements are equal to zero
cout << "Are all of the elements in myHugeInteger0 equal to zero?\n\n";
cout << myHugeInteger0.isZero() << endl << endl;
cout << "Are all of the elements in myHugeInteger1 equal to zero?\n\n";
cout << myHugeInteger1.isZero() << endl << endl;
cout << "Are all of the elements in myHugeInteger2 equal to zero?\n\n";
cout << myHugeInteger2.isZero() << endl << endl;
//intro to adding the objects
cout << "\n\n" << endl;
cout << "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~" << endl;
cout << "Now we shall add the different arrays together.\n" << endl;
system("pause");
cout << endl;
//add the different objects
myHugeInteger3 = myHugeInteger0.add(myHugeInteger1);
cout << "\nThe sum of myHugeInteger0 plus myHugeInteger1 equals\n\n";
myHugeInteger3.output();
cout << endl;
myHugeInteger3 = myHugeInteger0.add(myHugeInteger2);
cout << "\nThe sum of myHugeInteger0 plus myHugeInteger2 equals\n\n";
myHugeInteger3.output();
cout << endl;
myHugeInteger3 = myHugeInteger1.add(myHugeInteger2);
cout << "\nThe sum of myHugeInteger1 plus myHugeInteger2 equals\n\n";
myHugeInteger3.output();
//intro to subtracting the objects
cout << "\n\n" << endl;
cout << "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~" << endl;
cout << "Now we shall subtract the different arrays.\n" << endl;
system("pause");
//subtract the different objects
myHugeInteger3 = myHugeInteger0.subtract(myHugeInteger1);
cout << "\nThe difference of myHugeInteger0 minus myHugeInteger1 equals\n\n";
myHugeInteger3.output();
cout << endl;
myHugeInteger3 = myHugeInteger1.subtract(myHugeInteger0);
cout << "\nThe difference of myHugeInteger1 minus myHugeInteger0 equals\n\n";
myHugeInteger3.output();
cout << endl;
myHugeInteger3 = myHugeInteger0.subtract(myHugeInteger2);
cout << "\nThe difference of myHugeInteger0 minus myHugeInteger2 equals\n\n";
myHugeInteger3.output();
cout << endl;
myHugeInteger3 = myHugeInteger2.subtract(myHugeInteger0);
cout << "\nThe difference of myHugeInteger2 minus myHugeInteger0 equals\n\n";
myHugeInteger3.output();
cout << endl;
myHugeInteger3 = myHugeInteger1.subtract(myHugeInteger2);
cout << "\nThe difference of myHugeInteger1 minus myHugeInteger2 equals\n\n";
myHugeInteger3.output();
cout << endl;
myHugeInteger3 = myHugeInteger2.subtract(myHugeInteger1);
cout << "\nThe difference of myHugeInteger2 minus myHugeInteger1 equals\n\n";
myHugeInteger3.output();
cout << endl;
//intro to multipling the objects
cout << "\n\n" << endl;
cout << "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~" << endl;
cout << "Now we shall multiply the different arrays together.\n" << endl;
system("pause");
//multiply the different objects
myHugeInteger3 = myHugeInteger0.multiply(myHugeInteger1);
cout << "\nThe product of myHugeInteger0 times myHugeInteger1 equals\n\n";
myHugeInteger3.output();
cout << endl;
myHugeInteger3 = myHugeInteger0.multiply(myHugeInteger2);
cout << "\nThe product of myHugeInteger0 times myHugeInteger2 equals\n\n";
myHugeInteger3.output();
cout << endl;
myHugeInteger3 = myHugeInteger1.multiply(myHugeInteger2);
cout << "\nThe product of myHugeInteger1 times myHugeInteger2 equals\n\n";
myHugeInteger3.output();
cout << endl;
//intro to dividing the objects
cout << "\n\n" << endl;
cout << "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~" << endl;
cout << "Now we shall divide the different arrays.\n" << endl;
system("pause");
//divide the different objects
myHugeInteger3 = myHugeInteger0.divide(myHugeInteger1);
cout << "\nThe dividen of myHugeInteger0 divided by myHugeInteger1 equals\n\n";
myHugeInteger3.output();
cout << endl;
myHugeInteger3 = myHugeInteger0.divide(myHugeInteger2);
cout << "\nThe dividen of myHugeInteger0 divided by myHugeInteger2 equals\n\n";
myHugeInteger3.output();
cout << endl;
myHugeInteger3 = myHugeInteger1.divide(myHugeInteger2);
cout << "\nThe dividen of myHugeInteger1 divided by myHugeInteger2 equals\n\n";
myHugeInteger3.output();
cout << endl;
myHugeInteger3 = myHugeInteger2.divide(myHugeInteger1);
cout << "\nThe dividen of myHugeInteger2 divided by myHugeInteger1 equals\n\n";
myHugeInteger3.output();
cout << endl;
//intro to comparing objects
cout << "\n\n" << endl;
cout << "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~" << endl;
cout << "Now we shall compare the different arrays.\n" << endl;
system("pause");
cout << endl;
//see if the objecs are equal
cout << "Is myHugeInteger0 equal to myHugeInteger1? \n\n";
cout << myHugeInteger0.isEqual(myHugeInteger1) << endl << endl;
cout << "Is myHugeInteger0 equal to myHugeInteger2? \n\n";
cout << myHugeInteger0.isEqual(myHugeInteger2) << endl << endl;
cout << "Is myHugeInteger1 equal to myHugeInteger2? \n\n";
cout << myHugeInteger1.isEqual(myHugeInteger2) << endl << endl;
//see if the objects are not equal
cout << "Is myHugeInteger0 not equal to myHugeInteger1? \n\n";
cout << myHugeInteger0.isNotEqual(myHugeInteger1) << endl << endl;
cout << "Is myHugeInteger0 not equal to myHugeInteger2? \n\n";
cout << myHugeInteger0.isNotEqual(myHugeInteger2) << endl << endl;
cout << "Is myHugeInteger1 not equal to myHugeInteger2? \n\n";
cout << myHugeInteger1.isNotEqual(myHugeInteger2) << endl << endl;
//see if the objects are greater than
cout << "\nThat is all for today! Thank you for watching!\n" << endl;
system("pause");
return 0;
}
Каждый раз, когда я запускаю свою программу для сравнения двух объектов, она возвращает значение true, несмотря ни на что. Не могу понять, что я делаю не так или как это исправить. Любая помощь очень ценится! Благодарю вас!
1 ответ
Вы создаете новый местный bool result внутри условия в вашем для цикла, так что result вы всегда возвращаете свой тот, который имеет значение true.
Чтобы избежать ошибок такого типа и облегчить их чтение, я бы порекомендовал всегда предоставлять скобки вокруг ваших условий и циклов, даже если технически они не требуются.
bool HugeInteger::isEqual(HugeInteger other) //test equal function
{
bool result = true;
for (int i = 0; i < MAXINTEGER; i++)
{
if (this->hugeIntergerOne[i] != other.hugeIntergerOne[i])
{
result = false; // You had: bool result = false;
}
}
return result;
}
Изменить - дальнейшее объяснение
В этих строках кода вы создаете новый бул result который будет существовать только до выхода из оператора if. Если вы добавите фигурные скобки, вы увидите, где заканчивается область. Из-за этого вы устанавливаете локальную область result в false, но функция ограничена result сохраняет первоначальное значение true, которое вы дали в начале функции.
if (this->hugeIntergerOne[i] != other.hugeIntergerOne[i])
bool result = false;
Если мы напишем эти строки с фигурными скобками, то станет более понятным, какова область действия:
if (this->hugeIntergerOne[i] != other.hugeIntergerOne[i])
{
bool result = false; // This is only in scope within the surrounding braces
}
Редактировать 2 - Практическое предложение по кодированию
Как указано jww в комментариях ваши функции сравнения копируют HugeInteger Класс каждый раз, когда вы звоните одному из них. Не вдаваясь в подробности (вы можете найти это или прочитать учебник для деталей), лучше всего пройти const & к объекту, так что вторая копия объекта не создается при вызове функции. Также рекомендуется помечать функции как const, когда это возможно. Функция const указывает, что она не изменит состояния самого объекта. Не имеет побочных эффектов". Это важно, когда мы говорим о многопоточности и безопасности потоков объектов.
bool HugeInteger::isEqual(const HugeInteger& other) const //test equal function
{
bool result = true;
for (int i = 0; i < MAXINTEGER; i++)
{
if (this->hugeIntergerOne[i] != other.hugeIntergerOne[i])
{
result = false; // You had: bool result = false;
}
}
return result;
}