运算符重载2

#ifndef BYTE_H
#define BYTE_H

#include <iostream>

class Byte
{
	unsigned char b;
public:
	Byte(unsigned char bb = 0) : b(bb){}
	void print() const
	{
		std::cout << (int)b << std::endl;
	}

	const Byte& operator+() 
	{
		std::cout << "+Byte\n";
		return *this;
	}

	const Byte operator-()
	{
		std::cout << "-Byte\n";
		return Byte(-b);
	}

	const Byte operator~()
	{
		std::cout << "~Byte\n";
		return Byte(~b);
	}

	Byte* operator&()
	{
		std::cout << "&Byte\n";
		return this;
	}

	int operator!()
	{
		std::cout << "!Byte\n";
		return !b; // 这个是逻辑非，返回是bool值，
	}

	const Byte& operator++()  // 这个是前++
	{
		std::cout << "前++Byte\n";
		b++;
		return *this;
	}

	const Byte operator++(int)  // 这个是后++
	{
		std::cout << "后++Byte\n";
		Byte before(b);
		b++;
		return before;
	}

	const Byte& operator--()  // 这个是前--
	{
		std::cout << "前--Byte\n";
		b--;
		return *this;
	}

	const Byte operator--(int)  // 这个是后--
	{
		std::cout << "后++Byte\n";
		Byte before(b);
		b--;
		return before;
	}

	const Byte operator+(const Byte& right) const
	{
		return Byte(b + right.b);
	}

	const Byte operator-(const Byte& right) const
	{
		return Byte(b - right.b);
	}

	const Byte operator*(const Byte& right) const
	{
		return Byte(b * right.b);
	}

	const Byte operator/(const Byte& right) const
	{
		return Byte(b / right.b);
	}

	const Byte operator&(const Byte& right) const
	{
		return Byte(b & right.b);
	}

	const Byte operator%(const Byte& right) const
	{
		return Byte(b % right.b);
	}
	const Byte operator^(const Byte& right) const
	{
		return Byte(b ^ right.b);
	}
	const Byte operator|(const Byte& right) const
	{
		return Byte(b | right.b);
	}
	const Byte operator<<(const Byte& right) const
	{
		return Byte(b << right.b);
	}
	const Byte operator>>(const Byte& right) const
	{
		return Byte(b >> right.b);
	}


	Byte& operator+=(const Byte& right)
	{
		b += right.b;
		return *this;
	}
	Byte& operator-=(const Byte& right)
	{
		b -= right.b;
		return *this;
	}
	

	int operator==(const Byte& right) const
	{
		return b == right.b;
	}


	Byte& operator=(const Byte& right)   // 赋值操作必须是成员函数，[]、()、->、->* 也都必须是成员函数，
	{
		if (this == &right) return *this;
		b = right.b;
		return *this;
	}
};



#endif

#ifndef INTEGER_H
#define INTEGER_H

#include <iostream>

class Integer
{
	long i;
	Integer* This() { return this; }
public:
	Integer(long ii = 0) : i(ii){}
	void print() const
	{
		std::cout << i << std::endl;
	}

	friend const Integer& operator+(const Integer& a);
	friend const Integer operator-(const Integer& a);
	friend const Integer operator~(const Integer& a);
	friend Integer* operator&(Integer& a);
	friend int operator!(const Integer& a);
	friend const Integer& operator++(Integer& a);
	friend const Integer operator++(Integer& a, int);
	friend const Integer& operator--(Integer& a);
	friend const Integer operator--(Integer& a, int);

	friend const Integer operator+(const Integer& left, const Integer& right);
	friend const Integer operator-(const Integer& left, const Integer& right);
	friend const Integer operator*(const Integer& left, const Integer& right);
	friend const Integer operator/(const Integer& left, const Integer& right);

	friend const Integer operator%(const Integer& left, const Integer& right);
	friend const Integer operator^(const Integer& left, const Integer& right);
	friend const Integer operator&(const Integer& left, const Integer& right);
	friend const Integer operator|(const Integer& left, const Integer& right);
	friend const Integer operator<<(const Integer& left, const Integer& right);
	friend const Integer operator>>(const Integer& left, const Integer& right);

	friend Integer& operator+=(Integer& left, const Integer& right);
	friend Integer& operator-=(Integer& left, const Integer& right);

	friend int operator==(const Integer& left, const Integer& right);
	friend int operator<(const Integer& left, const Integer& right);
};

const Integer& operator+(const Integer& a) // 改变了，返回一个引用，
{
	std::cout << "+Integer\n";
	return a;
}

const Integer operator-(const Integer& a)
{
	std::cout << "-Integer\n";
	return Integer(-a.i);  // 这个不是引用返回的是一个新的对象
}

const Integer operator~(const Integer& a)
{
	std::cout << "~Integer\n";
	return Integer(~a.i); // ~ 这个是按位取反，
}

Integer* operator&(Integer& a)
{
	std::cout << "&Integer\n";
	return a.This();
}

int operator!(const Integer& a)
{
	std::cout << "!Integer\n";
	return !a.i; // 这个是逻辑非，返回是bool值，
}

const Integer& operator++(Integer& a)  // 这个是前++
{
	std::cout << "前++Integer\n";
	a.i++;
	return a;
}

const Integer operator++(Integer& a, int)  // 这个是后++
{
	std::cout << "后++Integer\n";
	Integer before(a.i);
	a.i++;
	return before;
}

const Integer& operator--(Integer& a)  // 这个是前--
{
	std::cout << "前--Integer\n";
	a.i--;
	return a;
}

const Integer operator--(Integer& a, int)  // 这个是后--
{
	std::cout << "后++Integer\n";
	Integer before(a.i);
	a.i--;
	return before;
}

const Integer operator+(const Integer& left, const Integer& right) // 加法操作，
{
	return Integer(left.i + right.i);
}

const Integer operator-(const Integer& left, const Integer& right) // 减法操作，
{
	return Integer(left.i - right.i);
}

const Integer operator*(const Integer& left, const Integer& right) 
{
	return Integer(left.i * right.i);
}

const Integer operator/(const Integer& left, const Integer& right) 
{
	return Integer(left.i / right.i);
}


const Integer operator%(const Integer& left, const Integer& right)
{
	return Integer(left.i % right.i);
}
const Integer operator^(const Integer& left, const Integer& right) // 异或
{
	return Integer(left.i ^ right.i);
}
const Integer operator&(const Integer& left, const Integer& right) // 位与
{
	return Integer(left.i & right.i);
}
const Integer operator|(const Integer& left, const Integer& right) // 位或
{
	return Integer(left.i | right.i);
}

const Integer operator<<(const Integer& left, const Integer& right)
{
	return Integer(left.i << right.i);
}
const Integer operator>>(const Integer& left, const Integer& right)
{
	return Integer(left.i >> right.i);
}


Integer& operator+=(Integer& left, const Integer& right)
{
	left.i += right.i;
	return left;
}
Integer& operator-=(Integer& left, const Integer& right)
{
	left.i -= right.i;
	return left;
}


int operator==(const Integer& left, const Integer& right)
{
	return left.i == right.i;
}
int operator<(const Integer& left, const Integer& right)
{
	return left.i < right.i;
}


#endif

#include <iostream>
#include "integer.h"
#include "Byte.h"

using namespace std;

class IntArray
{
	enum { sz = 5 };
	int i[sz];
public:
	IntArray() { memset(i, 0, sz*sizeof(*i)); } // memset 把分配的内存清零，
	int& operator[](int x) // 这个就是下标运算符重载，必须做成是成员函数，
	{
		return i[x];
	}
	~IntArray() {}
	friend ostream& operator<<(ostream& os, const IntArray& ia);
	friend istream& operator>>(istream& is, IntArray& ia);
};

ostream& operator<<(ostream& os, const IntArray& ia)  // ostream 是输出流，
{
	for (int j = 0; j < ia.sz; j++)
	{
		os << ia.i[j];
		if (j != ia.sz - 1)
			os << ", ";
	}
	os << endl;
	return os;
}

istream& operator>>(istream& is, IntArray& ia)  // istream 是输入流，
{
	for (int j = 0; j < ia.sz; j++)
		is >> ia.i[j];
	return is;
}

void test66()
{
	/*Integer in(80);
	Integer test;*/
	Byte in(80);
	Byte test;
	test = +in;
	test.print();
	test = -in;
	test.print();
	test = ~in;
	test.print();

	//Integer *ip = ∈ // 指针的地址，
	Byte *ip = ∈
	cout << ip << endl;

	int r = !in;
	cout << r << endl;

	in.print(); // 80
	++in;
	in.print(); // 81

	test = in++;
	test.print(); // 81
	in.print();  // 82

	--in;
	in.print();// 81

	test = in--;
	test.print();// 81
	in.print();// 80
}

void test88()
{
	Integer x(10);
	Integer y(20);
	Integer z;

	z = x + y;
	z.print();

	z = x % y;
	z.print();

	z = x << y;
	z.print();

	x += y;
	x.print();

	int result;
	result = (x == y);
	cout << result << endl << endl;

	result = (x < y);
	cout << result << endl << endl;


	Byte m(11);
	Byte n(10);
	Byte k;

	k = m + n;
	k.print();

	m += n;
	m.print();

	int cc;
	cc = (m == n);
	cout << cc << endl << endl;

	n = n;
	n.print();
	n = m;
	n.print();
}

int main()
{
	//test66();
	//test88();

	int x, y;
	IntArray a;
	a[0] = 60;
	a[1] = 80;
	a[2] = 100;
	a[3] = 130;
	cout << a[0] << ", " << a[1] << ", " << a[2] << endl << endl;
	cout << a;

	/*cin >> a;
	cout << a;*/

	cin >> a >> x >> y; // 这个可以表示连续的输入，
	cout << a << x << ", " << y << endl;

	return 0;
}