Long arithmetics - delete-file

Question

Do something with it guys
They ask to add something
because it looks like my post is mostly code.
I hope it's enough.
There's no way to delete it.
Solong sum;
sum = 0;
for (int i = 0; i != 10; ++i) {
if ((i != 0) && (i != 8)) {
sum = sum + n2[i];
}
}
std::cout << sum;
std::cout << std::endl;
}

Answer 1

These are the problems that punched me in the face looking at your code -- so I might have missed a few less obvious things.
operator = (const int & b), ignores the argument's value and just makes the low-order word zero. So I'm thinking you want number[0] = b;. You also need to update size. You should also probably take care of the case when b overflows your radix, setting size and populating higer-order words.
In operator +, a radix digit overflow is detected and the carry flag is set, but the result's digit is never reduced by the value represented by the carry to the next digit:
if (res.number[i] >= res.radix) {
overDecimal = 1;
}
So this needs something like res.number[i] -= res.radix
Also, high-order words beyond its size are used when one argument has a smaller size than the other. The assignment operators do not bother to make sure that their high-order words, above size are set to zero, so you either need to make sure they are set to zero everywhere else, or ignore these non-zero high-order words in this function.
In the loop in void operator <<, your index i starts at the last element, but is updated by incrementing:
for (int i=a.size-1; ...; ++i) { ...
So I'm guessing this needs to be changed to --i
Some other problems:
Both operator = (... should return Solong& instead of void, with return *this; at the end.
operator << (std::ostream& out, const Solong &a) should return std::ostream& instead of void, with return out; at the end.

Answer 2

First: Your program caused a segmentation fault in this function:
> void operator << (std::ostream& out, const Solong &a) {
> for (int i = a.size - 1; i != -1 || (i != a.size - 1 && a.number[a.size - 1] == 0); ++i) {
x > out << a.number[i];
> }
> }
You can find this line by using a debugger. On linux you may want to use gdb. If you are using some IDE, it should be integrated there. I'm not sure what you want to do in this function. Maybe you could just write this?
for (int i = a.size - 1; i >= 0; --i) out << a.number[i];
The program dosen't crash anymore after changing this. I got -1087373312 as result for 42 but you have undefined behavior in your application. I get another result each time I run it. Now I will show some other things I would change. It did work for me after doing this:
I would use std::vector to store the numbers. This container would hold the size for you and you can change it by using resize:
class Solong {
private:
int radix = 10;
std::vector<int> number;
I have to change the constructor then:
public:
Solong() :
number(1, 1) // are you shure you want initialize it with 1 instead of 0?
{}
You may also want to have a constructor to set the initial value.
Solong(const int &value)
{
*this = value;
}
The operator<< sould return a reference to out:
friend Solong operator+ (const Solong &a, const Solong &b);
friend std::ostream &operator<< (std::ostream &out, const Solong &a);
Since I'm not using an array in this class anymore, I can use the implicit definition of operator=(const Solong &b). I would just remove the custom definition of operator=(const Solong &b) from the class.
I think you want to assign b to number instead of 0 in the function operator=(const int &b). You should return a reference to the object itself as well. Since you only allow 0-9 per int, you have to ensure this, too.
void operator= (int b) {
this->number.clear();
while (b > 0) {
this->number.push_back(b % radix);
b = b / radix;
}
}
};
For operator+ there are multiple things:
I have to use resize of number now.
If you want to put the definition in a header file, you have to specify inline.
The condition || overDecimal seems wrong to me, since they can cause a segmentation fault.
You have to check if a.number[i] and b.number[i] is valid before reading this value.
And you should change res.number[i] if there is an overflow
Here is my updated implementation:
inline Solong operator+ (const Solong &a, const Solong &b) {
Solong res;
res.number.resize(std::max(a.number.size(), b.number.size()));
int overDecimal = 0;
for (std::size_t i = 0; i < res.number.size(); ++i) {
int aDigit = (a.number.size() > i ? a.number[i] : 0);
int bDigit = (b.number.size() > i ? b.number[i] : 0);
res.number[i] = aDigit + bDigit + overDecimal;
overDecimal = 0;
if (res.number[i] >= res.radix) {
overDecimal = 1;
res.number[i] = res.number[i] % res.radix;
}
}
if (overDecimal)
res.number.push_back(overDecimal);
return res;
}
Finally I fixed operator<< just like written above, added the keyword inline and return a reference to out:
inline std::ostream &operator<< (std::ostream &out, const &a) {
for (int i = a.number.size() - 1; i >= 0; --i) {
out << a.number[i];
}
return out;
}
I would also change i to std::size_t and use the whole size of int for one digit. Not just 10 values per int. I would then changed the name of overDecimal to overflowedDigit of cource since there would be no decimalism anymore. You should also consider that you are not supporting negative numbers right now. But all this would add some complexity and I don't want descripe it now.