1.前言
实现大数的加减乘除是今年寒假C++的大作业，原本我是用字符串写的，但是后来看作业要求要用链表实现，于是我不情不愿的用链表的实现了一遍
2.Num类
2.1Node类
首先是内部的一个Node类用于建立单向链表，size用于计算大小方便Num对象之间做比较
class Node
{
public:
int val;
Node*next;
Node(int v, Node*n)
{
val = v;
next = n;
}
};
Node*head;
int size;2.2构造函数，赋值函数以及析构函数
首先是默认构造函数，其实可能不会使用到，但为了方便，还是写了
Num()
{
head = NULL;
size = 0;
D = false;
}然后是主要的一个构造函数，当遇到'.'的时候，我们用-100来作为标记
该链表为逆向构造的一个数，方便进行加减操作
Num(const string&s)
{
D = false;
head = NULL;
size = 0;
for (int i = 0; i < s.size(); i++)
{
if (s[i] == ','||s[i]=='-')
continue;
size++;
if (s[i] == '.')
head = new Node(-100, head);
else
head = new Node(s[i] - '0', head);
}
}接下来是拷贝构造函数以及赋值函数，两者基本是一样的
值得注意的是，赋值函数要首先确认赋值对象是否为本身，若为本身，则返回
Num(const Num& num)
{
D = num.D;
size = num.size;
head = NULL;
Node*cur = num.head, *temp=head;
while (cur)
{
if (!head)
{
head = new Node(cur->val, NULL);
temp = head;
}
else
{
temp->next = new Node(cur->val, NULL);
temp = temp->next;
}
cur = cur->next;
}
}
Num& operator=(const Num&num)
{
if (this == &num)
return *this;
free();
size = num.size;
head = NULL;
D = num.D;
Node*cur = num.head, *temp=head;
while (cur)
{
if (!head)
{
head = new Node(cur->val, NULL);
temp = head;
}
else
{
temp->next = new Node(cur->val, NULL);
temp = temp->next;
}
cur = cur->next;
}
return *this;
}最后是析构函数，我们析构函数只需要回收掉链表的内存即可
为了方便函数内部回收链表内存，将回收操作写为free函数
~Num()
{
free();
}
void free()
{
size = 0;
while (head)
{
Node*temp = head->next;
delete head;
head = temp;
}
head = NULL;
}上述即为Num类的基本组成函数
2.3加法操作与减法操作
为方便操作，加减时大数在前，小数在后，直接对本身对象进行操作，所以使用+=,-=以及返回对象本身引用
加减操作没什么好说的，从最低位开始依次相加
在进位或借位时进行了一个判断是否为小数点的操作，以防操作错误
Num& operator+=(const Num&num)
{
Node*pa = head, *pb = num.head;
while (pa||pb)
{
int b = 0;
if (pb)
{
b = pb->val;
pb = pb->next;
}
if (pa->val != -100)
{
pa->val += b;
if (pa->val > 9)
{
if (pa->next)
{
if (pa->next->val == -100)
pa->next->next->val++;
else
pa->next->val++;
}
else
{
pa->next = new Node(1, NULL);
size++;
}
pa->val -= 10;
}
}
pa = pa->next;
}
return *this;
}
Num& operator-=(const Num&num)
{
Node*pa = head, *pb = num.head;
while (pa || pb)
{
int b = 0;
if (pb)
{
b = pb->val;
pb = pb->next;
}
if (pa->val != -100)
{
pa->val -= b;
if (pa->val < 0)
{
if (pa->next->val == -100)
pa->next->next->val--;
else
pa->next->val--;
pa->val += 10;
}
}
pa = pa->next;
}
return *this;
}2.4乘法操作
乘法操作其实和列式计算一样，涉及到进位，但很容易理解
Num operator*(const Num&num)
{
Num res(string(size + num.size, '0'));
Node *pr = res.head, *temp;
for (Node*pa = head; pa != NULL; pa = pa->next)
{
int carry = 0;
temp = pr;
for (Node*pb = num.head; pb != NULL; pb = pb->next,pr=pr->next)
{
int temp = pa->val*pb->val + carry + pr->val;
pr->val = temp % 10;
carry = temp / 10;
}
pr->val += carry;
pr = temp->next;
}
return res;
}2.5除法操作
除法操作我们使用被除数减去除数乘以若个干10进行
比如58除以5 首先用58-50=8 然后商加10 然后用8-5=3 商加1 由于3比5小，就不进行操作了 最终结果为11
但是题目要求除法操作要保留十位小数四舍五入，我们只需要事先对被除数乘以10^11即可，最终再加上小数点进行四舍五入操作
我们首先实现了两个与10有关的函数
void Mul10(const int& x)
{
for (int i = 0; i < x; ++i)
{
head = new Node(0, head);
size++;
}
}
void Div10(const int&x)
{
for (int i = 0; i < x; ++i)
{
Node*temp = head->next;
delete head;
head = temp;
size--;
}
}然后是除法操作，res用于返回结果，p用于与res相加
d用于与被除数相减
Num operator/(const Num&num)
{
Num res(string(1, '0')), p(string(1, '1'));
res.D = true;
p.D = true;
Num d = num;
while (num<=*this)
{
int len = size - num.size;
d.Mul10(len);
p.Mul10(len);
int z = 0;
if (*this < d)
{
d.Div10(1);
p.Div10(1);
z = -1;
}
if (res.head->val == 0&&res.size==1)
res = p;
else
res += p;
*this -= d;
balance();
d.Div10(len + z);
p.Div10(len + z);
}
return res;
}我们注意到了除法操作中有比较<的操作，接下来便是重载<函数
暂时写成单向链表转化为字符串string比较的方法
bool operator<(const Num&num)const
{
if (size < num.size)
return true;
else if (size > num.size)
return false;
string A(size, '0'), B(num.size, '0');
Node*temp = head;
for (int i = size - 1; i >= 0; --i)
{
if (temp->val == -100)
A[i] = '.';
else
A[i] = temp->val + '0';
temp = temp->next;
}
temp = num.head;
for (int i = num.size - 1; i >= 0; --i)
{
if (temp->val == -100)
B[i] = '.';
else
B[i] = temp->val + '0';
temp = temp->next;
}
return cmp(A, B);
}
bool cmp(const string&a, const string&b)const
{
if (a.size() < b.size())
return true;
else if (a.size() > b.size())
return false;
else
return a < b;
}
bool operator==(const Num&num)const
{
if (size != num.size)
return false;
Node*pa = head, *pb = num.head;
while (pa&&pb)
{
if (pa->val != pb->val)
return false;
pa = pa->next;
pb = pb->next;
}
return true;
}
bool operator<=(const Num&num)const
{
return *this == num || *this < num;
}2.6打印数字
我们用一个bool值D来标记是否为除法结果，若D为真，则为商，需要进行小数点处理
我们需要考虑下列情况
1.若为小数点，将小数后面0清空，若全为0，则去掉小数点
2.将前导0去掉，若只剩小数点，则加0，或全为0，则为0
friend ostream& operator<<(ostream&os, const Num&num)
{
bool z = false;
Num::Node* temp = num.head;
string s(num.size, '0');
for (int i = num.size - 1; i >= 0; --i)
{
if (temp->val == -100)
{
s[i] = '.';
z = true;
}
else
s[i] = temp->val + '0';
temp = temp->next;
}
if (num.D)
{
if (s.size() <= 11)
s = "0" + string(11 - s.size(), '0') + s;
if (s[s.size() - 1] > '4')
s[s.size() - 2]++;
s.erase(s.end() - 1);
for (int j = s.size() - 1; j > 0; --j)
{
if (s[j] > '9')
{
s[j - 1]++;
s[j] -= 10;
}
else
break;
}
if (s[0] > '9')
{
s[0] -= 10;
s = "1" + s;
}
s.insert(s.size() - 10, ".");
z = true;
}
int n = 0;
while (s[n] == '0')
n++;
if (n == s.size())
s = "0";
else
s = s.substr(n);
if (s[0] == '.')
s = '0' + s;
bool t = true;
int q;
for (q = 0; q < s.size(); ++q)
if (s[q] == '.')
break;
int j = s.size() - 1;
if (z)
{
while (j > q&&s[j] == '0')
j--;
if (j == q)
j--;
}
for (int i = 0; i <= j; ++i)
{
if (s[i] == '.')
t = false;
if (t && (q - i) % 3 == 0 && i != 0)
os << ",";
os << s[i];
}
os << endl;
return os;
}2.7操作前处理
加减法将小数点对其，除法则将除数小数点去掉并将被除数扩大相应的倍数
void convert_Float_Plus(string&a, string&b)
{
int x = 0, y = 0;
while (x<a.size() && a[x] != '.')
x++;
while (y<b.size() && b[y] != '.')
y++;
if (x != a.size() || y != b.size())
{
int a_point = a.size() - x - 1, b_point = b.size() - y - 1;
if (a_point > b_point)
b += string(a_point - b_point, '0');
else if (a_point < b_point)
a += string(b_point - a_point, '0');
a[x] = '.';
b[y] = '.';
}
}
void convet_Float_Divide(string&a, string&b)
{
int x, y;
for (x = 0; x < a.size(); ++x)
if (a[x] == '.')
break;
for (y = 0; y < b.size(); ++y)
if (b[y] == '.')
break;
if (y < b.size())
{
if (x < a.size())
for (int i = 0; i < b.size() - y - 1; ++i)
swap(a[x + i], a[x + 1 + i]);
else
a = a + string(b.size() - y - 1, '0');
b.erase(b.begin() + y);
int n = 0;
while (b[n] == '0')
++n;
b = b.substr(n);
}
for (x = 0; x < a.size(); ++x)
if (a[x] == '.')
break;
if (x < a.size())
{
if (a.size() - x - 1 <11)
a = a + string(11 - (a.size() - x - 1), '0');
else
a = a.substr(0, x + 12);
a.erase(a.begin() + x);
}
else
a = a + string(11, '0');
}
779
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
