3.运算符的重载和大数运算

一.运算符的重载

#include<iostream>
using namespace std;

class FuN
{
private:
	int _a;
	int _bi;

public:
	FuN(int a, int b)
	{
		_a = a;
		_bi = b;
	}
	FuN(const FuN& src)//拷贝构造函数，如果不加引用，会构成死循环
	{
		_a = src._a;
		_bi = src._bi;
	}

	void show()
	{
		cout << "number=" << _a<<"+" << _bi << "i" << endl;
	}

	void operator=(/*this,*/const FuN& src)
	{
		this->_a = src._a;
		this->_bi = src._bi;
	}

	bool operator>(/*this*/const FuN& num)//*this > num
	{
		if (this->_a > num._a)
		{
			return true;
		}
		else if (this->_a < num._a)
		{
			return false;
		}
		else if (this->_bi > num._bi)
		{
			return true;
		}
		else
		{
			return false;
		}
	}

    FuN operator+(/*this,*/int a)//*this+a    //不是前置加加，也不是后置加加，只是单纯加a
	{
		return FuN(_a + a, _bi);
	}

	//FuN operator+(this)
	//前置++  参数列表为空（除开this指针）
	FuN& operator++()   //++(*this)
	{
		_a++;
		_bi++;
		return *this;
	}

	//后置++   参数别表中加入int
	FuN operator++(int)
	{
		FuN tmp(_a, _bi);
		_a++;
		_bi++;
		return tmp;
	}

	//输出运算符  <<        cout<<a
	void operator<<(/*this,*/ostream& out)
	{
		out << _a << "+" << _bi << "i" << endl;  //_bi是一个整形
	}

	void operator>>(istream& in)
	{
		in >> _a;
		in >> _bi;
	}

	friend FuN operator+(int a, const FuN& n);      //类外的函数需要访问私有成员需要声明友元
	friend ostream& operator<<(ostream& out, const FuN& n);
	friend istream& operator>>(istream& in, FuN& n);
};

ostream& operator<<(ostream& out, const FuN& n)
{
	out << n._a << "+" << n._bi << "i" << endl;
	return out;
}

istream& operator>>(istream& in, FuN& n)
{
	in >> n._a;
	in >> n._bi;
	return in;
}
//输出流对象类型是  ostream    输出流对象 cout
//输入流对象类型是  istream    输入流对象 cin
FuN operator+(int a, const FuN& n)
{
	return FuN(n._a + a, n._bi);
}
int main()
{
	FuN a1(2, 4);
	//a1.show();

	FuN a2(3, 7);
	//a2.show();

	//a2 = a1;
	//a2.show();
	int a = 10;
	int b = a++;


	if (a1 > a2)
	{
		a1.show();
	}
	else if(a2 > a1)
	{
		a2.show();
	}
	else
	{
		cout << "a1 == a2" << endl;
	}


	FuN a3(1, 1);
	FuN a4 = ++a3;
	

	a4.show();//2+2i
	a3.show();//2+2i

	a4 = a3++;
	a3.show();//3+3i
	a4.show();//2+2i


	a4 = a3 + 7;
	a4.show();//10+3i;

	a4 = 7 + a3;
	a4.show();

	cout << 10 << endl;

	ostream& zpl = cout;
	zpl << 20 << endl;

	a4.operator<<(cout);


	cout << a4 <<a3<< endl;
	//ostream  <<  FuN    --->    ostream   <<   endl;


	//a4.operator>>(cin);
	//cout << a4 << endl;


	cin >> a4 >> a3;
	cout << a4 << a3 << endl;


	return 0;
}
#endif

二.大数运算

bignum.h

#ifndef BIG_NUM_H
#define BIG_NUM_H
#include<vector>
#include<iostream>
#include<string>
using namespace std;

class BigNum
{
private:
	int _tag;//-1   负数    +1 正数
	vector<int> _vec;

	int char_to_int(char c);

	vector<int> sum(const vector<int>&a, const vector<int>&b);
	vector<int> sub(const vector<int>&a, const vector<int>&b,int &tag);
public:
	BigNum();
	BigNum(const string& str);
	BigNum(const BigNum& src);
	~BigNum();

	BigNum operator=(const BigNum& src);
	BigNum operator=(const string& src);
	BigNum operator+(const BigNum& src);
	BigNum operator-(const BigNum& src);
	bool operator==(const BigNum& src);
	bool operator!=(const BigNum& src);
	BigNum operator++();
	BigNum operator++(int);
	bool operator>(const BigNum& src);
	bool operator<(const BigNum& src);
};
#endif

bignum.cpp

#include"bignum.h"

BigNum::BigNum() :_tag(1){}  //初始化列表
BigNum::BigNum(const string& str) 
{
	if (0 == str.size())
	{
		return;
	}

	str[0] == '-' ? _tag = -1 : _tag = 1;
	
	for (int i = str.size()-1; i >=0 ; i--)
	{
		if (str[i] == '-')
		{
			continue;
		}
		int a = char_to_int(str[i]);
		if (a == -1)
		{
			cout << "error" << endl;
			break;
		}
		_vec.push_back(a);
	}

	while (_vec.back() == 0)
	{
		_vec.pop_back();
	}
	
}
BigNum::BigNum(const BigNum& src) //拷贝构造函数
	//:_vec(src._vec)
{                                  //初始化列表
	_tag = src._tag;     //符号位
	_vec = src._vec;     //表示逆序存储的数组
}

int BigNum::char_to_int(char c)
{
	int arr[] = { 0,1,2,3,4,5,6,7,8,9 };
	char err[] = { '0','1','2','3','4','5','6','7','8','9' };
	for (int i = 0; i < sizeof(err); i++)
	{
		if (c == err[i])
		{
			return arr[i];
		}
	}
	return -1;
}

vector<int> BigNum::sum(const vector<int>& a, const vector<int>& b)
{
	int val;
	int tmp = 0;
	int i;
	vector<int> vec;     //将前面长度相等的部分先相加
	for (i = 0; i < a.size() && i < b.size(); i++)
	{
		val = a[i] + b[i]+tmp;
		tmp = val / 10;  //tmp是判断是否进位      如345+567,实际存放方式为：543+765
		val = val % 10;  //val是保存进位后的值
		vec.push_back(val);
	}

	if (a.size() == b.size())
	{
		if (tmp != 0)
		{
			vec.push_back(tmp);
		}
		return vec;
	}
	const vector<int>* p;    //再将截取后剩下的部分进行加
	a.size() < b.size() ? p = &b : p = &a;

	for (; i < p->size(); i++)
	{
		val = (*p)[i] + tmp;
		tmp = val / 10;
		val = val % 10;
		vec.push_back(val);
	}
	if (tmp != 0)
	{
		vec.push_back(tmp);
	}

	return vec;
}

vector<int> BigNum::sub(const vector<int>& a, const vector<int>& b, int& tag)
{
	vector<int> vec;
	if (b.size() > a.size())
	{
		vec = sub(b, a, tag);
		_tag = -1;
		return;
	}
	if (b.size() == a.size())
	{
		for (int i = a.size() - 1; i >= 0; i--)
		{
			if (a[i] < b[i])
			{
				vec = sub(b, a, tag);
				_tag = -1;
				return;
			}
			else if (a[i] > b[i])
			{
				break;
			}	
		}
	}
	int val1;
	int val2;
	int tmp = 0;
	int i = 0;
	

	for (; i < a.size() && i < b.size(); i++)
	{
		if (a[i] + tmp < b[i])
		{
			val1 = a[i]+10+tmp;
			tmp = -1;
		}
		else
		{
			val1 = a[i]+tmp;
			tmp = 0;
		}
		val2 = val1 - b[i];
		vec.push_back(val2);
	}
	if (a.size() == b.size())
	{
		if (tmp != 0)
		{
			vec.push_back(1);
			tag = -1;
		}
	}
	const vector<int>* p;
	a.size() < b.size() ? p = &b : p = &a;
	for (; i <p->size(); i++)
	{
		if ((*p)[i] + tmp < 0)
		{
			val1 = (*p)[i] + 10 + tmp;
			tmp = -1;
		}
		else
		{
			val1 = (*p)[i] + tmp;
			tmp = 0;
		}
		vec.push_back(val1);
	}
}

BigNum BigNum::operator=(const BigNum& src)
{
	_tag = src._tag;
	_vec = src._vec;
	return* this;
}

BigNum BigNum::operator=(const string& src)
{
	BigNum tmp(src);  //用的是构造函数
	_tag = tmp._tag;
	_vec = tmp._vec;
}

BigNum BigNum::operator+(const BigNum& src)
{
	vector<int> tmp;
	int tag;
	if (_tag == -1 && src._tag == -1)
	{
		tmp = sum(_vec, src._vec);
		tag = -1;
	}
	if (_tag == 1 && src._tag == -1)
	{
		tmp = sub(_vec, src._vec,tag);
	}
	if (_tag == -1 && src._tag == 1)
	{
		tmp = sub(src._vec, _vec, tag);
	}
	if (_tag == 1 && src._tag == 1)
	{
		tmp = sum(_vec, src._vec);
		tag = 1;
	}

	BigNum num_tmp;
	num_tmp._tag = tag;
	num_tmp._vec = tmp;

	return num_tmp;
}

BigNum BigNum::operator-(const BigNum& src)
{
	vector<int> tmp;
	int tag;
	if (_tag == -1 && src._tag == -1)
	{
		tmp = sub(src._vec, _vec,tag);
	}
	if (_tag == 1 && src._tag == -1)
	{
		tmp = sum(_vec, src._vec);
		tag = 1;
	}
	if (_tag == -1 && src._tag == 1)
	{
		tmp = sum(src._vec, _vec);
		tag = -1;
	}
	if (_tag == 1 && src._tag == 1)
	{
		tmp = sub(_vec, src._vec, tag);
	}

	BigNum num_tmp;
	num_tmp._tag = tag;
	num_tmp._vec = tmp;

	return num_tmp;
}

bool BigNum::operator==(const BigNum& src)
{
	if (_tag != src._tag)
	{
		return false;
	}
	else if (_vec.size() != src._vec.size())
	{
		return false;
	}
	else
	{
		for (int i = 0; i < _vec.size(); i++)
		{
			if (_vec[i] != src._vec[i])
			{
				return false;
			}
		}
	}
	return true;
}
bool BigNum::operator!=(const BigNum& src)
{
	return !(*this == src);
}
BigNum BigNum::operator++()
{
	BigNum tmp("1");
	*this =  *this + tmp;
	return *this;
}
BigNum BigNum::operator++(int) 
{
	BigNum tmp= *this;
	 ++*this;
	return tmp;
}
bool BigNum::operator>(const BigNum& src) 
{
	if (*this == src)
	{
		return false;
	}
	else if (_vec[0] == 0 && src._vec[0] == 0 && _vec.size() == src._vec.size() && _vec.size() == 1)
	{
		return false;
	}
	else if (_tag == -1 && src._tag == 1)
	{
		return false;
	}
	else if(_tag == 1 && src._tag == -1)
	{
		return true;
	}
	else if (_tag == 1 && src._tag == 1)
	{
		for (int i = _vec.size()-1; i < _vec.size(); i++)
		{
			if (_vec[i] < src._vec[i])
			{
				return false;
			}
		}
		return true;
	}
	else if (_tag == -1 && src._tag == -1)
	{
		for (int i = 0; i < _vec.size(); i++)
		{
			if (_vec[i] > src._vec[i])
			{
				return false;
			}
		}
		return true;
	}*/
}
bool BigNum::operator<(const BigNum& src) 
{

}