4.运算符重载，explicit关键字和哑成员

一 短整形运算符重载

二 模拟String类运算符重载

三 SmallInt类运算符重载

四 explicit关键字

五 哑成员

一

短整形运算符重载

//短整形运算符重载
#define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <string.h>
using namespace std;
class Int
{
public:
	Int(long i = 0) : m_i(i)
	{}
	Int(const Int& x)
	{
		this->m_i = x.m_i;
	}
public:
	Int operator+(const Int& x)
	{
		return Int(this->m_i + x.m_i);
	}
	Int operator-(const Int& x)
	{
		return Int(this->m_i - x.m_i);
	}
	Int operator*(const Int& x)
	{
		return Int(this->m_i * x.m_i);
	}
	Int operator/(const Int& x)
	{
		return Int(this->m_i / x.m_i);
	}
	Int operator%(const Int& x)
	{
		return Int(this->m_i % x.m_i);
	}
public:
	Int& operator+=(const Int& x) // a += b;
	{
		this->m_i += x.m_i;
		return *this;
	}
	Int& operator-=(const Int& x)
	{
		this->m_i -= x.m_i;
		return *this;
	}
	Int& operator*=(const Int& x)
	{
		this->m_i *= x.m_i;
		return *this;
	}
	Int& operator/=(const Int& x)
	{
		this->m_i /= x.m_i;
		return *this;
	}
	Int& operator%=(const Int& x)
	{
		this->m_i %= x.m_i;
		return *this;
	}
public:
	Int operator>>(const Int& x) //a >> b
	{
		return Int(this->m_i >> x.m_i);
	}
	Int operator<<(const Int& x)
	{
		return Int(this->m_i << x.m_i);
	}
	Int& operator>>=(const Int& x)
	{
		this->m_i >>= x.m_i;
		return *this;
	}
	Int& operator<<=(const Int& x)
	{
		this->m_i <<= x.m_i;
		return *this;
	}
public:
	bool operator==(const Int& x)
	{
		if (this->m_i == x.m_i)
			return true;
		return false;
	}
	bool operator!=(const Int& x)
	{
		if (this->m_i != x.m_i)
			return true;
		return false;
	}
public:
	Int& operator++() //前置++    比后置++效率    可以引用返回
	{
		this->m_i++;
		return *this;
	}
	Int operator++(int)  //后置++
	{
		Int temp(*this);   //调用拷贝构造函数或：
		//Int tmp(this->m_i);  //用构造函数
		this->m_i++;      //*this++
		return temp;
	}
	Int& operator--() //前置--    比后置++效率    可以引用返回
	{
		this->m_i--;
		return *this;
	}
	Int operator--(int)  //后置--
	{
		Int Tmp(m_i);
		this->m_i--;
		return Tmp;
	}
public:
	int GetData()const
	{
		return this->m_i;
	}
private:
	long m_i;
};

int main()
{
	Int a(1);  //int a = 1;  a++  ++a  a-- --a
	Int b(2);

	cout << "a = " << a.GetData() << endl;
	cout << "b = " << b.GetData() << endl;

	Int result;
	result = a + b; //result = 1 + 2;
	cout << "result = " << result.GetData() << endl;

	result = ++a;
	result = a++;

	return 0;
}

以上同类型的符号重载只分析一种，因为+ - += -= * *= / /= % %= 都是一样的逻辑，知一晓百

(1) +号的重载 有整数 a, b = 1, c = 2, d = 3 a = b + c + d; 上述加法要能正常执行就必须等号右边每两个数相加并返回结果，计算顺序是无关的 要先算出(b+c) = 3, 然后再算出来3 + d = 6 或者先算出来(c + d) = 5, 然后再算出来b + 5 = 6 最终将结果6返回给a

有Test类的对象 a, b (1), c(2), d(3)
对象之间是无法直接相加的，因此需要运算符重载
对+号进行重载成类的成员函数如下：
a = b + c + d;
相当于：a = b + c.operator+(d); a = b.operator+( c.operator+(d) ）;
或： a = b.operator+© + d; a = ( b.operator+© ).operator+(d);

Int operator+(const Int& x)
{
	return Int(this->m_i + x.m_i);
}

类的成员函数都是用对象来驱动的，被调用的成员方法的this指针便指向驱动它的对象
用this指针访问前对象的私有数据成员this->m_i，用常引用的形参const Int& x访问后对象的私有数据成员x.m_i，将数据相加然后构造一个临时对象，返回值按值返回，便实现了将两个对象相加，并将结果返回，于是连续的对象相加也能实现

(2) +=重载 对象加等于a += b; 就是 a = a + b ; 单看a += b 则重载的+=是用对象a驱动的，a.operator+=(b); 最终只有a的值发生了改变，所以b可以用常引用。对象a的生命不受重载的+=函数影响，所以a的值发生改变后可以引用返回，以值的方式返回也不会有任何问题。我们都知道函数参数按值返回会借助临时变量，由于是对象按值返回，这样的话就会多调用构造函数，即临时变量占用了内存空间又调用了构造函数，导致效率明显降低了。 所以函数中不受函数控制生存周期的变量，强烈建议用引用返回

Int& operator+=(const Int& x) // a += b;
{
	this->m_i += x.m_i;
	return *this;
}

(3) 以下右移位操作符>>和右移位等的操作符>>=重载和上面分析的+和+=是一样的道理

Int operator>>(const Int& x) //a >> b
{
	return Int(this->m_i >> x.m_i);
}


Int& operator>>=(const Int& x)
{
	this->m_i >>= x.m_i;
	return *this;
}

(4) ==操作符重载如下

bool operator==(const Int& x)
{
	if (this->m_i == x.m_i)
		return true;
	return false;
}

觉得上述啰嗦吧，也可以如下的写法：
但是上面的有更好的逻辑性，且返回值类型匹配都是布尔类型

 bool operator==(const Int& x)
{
	return (this->m_i == x.m_i)
}

(5) 前置++ 和后置++ 的重载

Int& operator++() //前置++ 比后置++ 效率 可以引用返回
{
this->m_i++;
return *this;
}

Int operator++(int)  //后置++
{
	Int temp(*this);   //调用拷贝构造函数或：
	//Int tmp(this->m_i);  //用构造函数
	this->m_i++;      //*this++
	return temp;
}

前置++ 和后置++ 的重载，其实相当简单，只需要知道后置++ 要在函数列表设一个int就OK
前置++ ，是给对象先+1，然后以引用返回
后置++ ，是先返回对象，再给对象+1，错错错，大错特错。再函数中一但返回，函数就结束了，return后面的语句就不再执行了
正确的思路是先借助临时变量记录一下++的左值，然后给左值+1，然后按值返回临时变量（不能用引用返回，语义上临时变量不能用引用返回，临时变量一出作用 域就死亡了，死亡的东西就是未知的也许，那块临时空间还保留着出函数的值，恰巧结果可以正确，但未知和不确定的实物可能就是整个程序死亡的诱因，要严谨要严谨）。

二

模拟String类运算符重载
对于3中对模拟String类实现的剖析的例子，我们继续对其进行运算符重载
实现友元函数：length()
重载以下运算符：

operator[]
operator+
operator+=
operator> 	
operator<	
operator>=	 
operator<=	 
operator==
operator!=

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
#include<assert.h>
#include<string.h>
using namespace std;

/
//length()
//operator[]
//operator+
//operator+=
//operator > < >= <= == !=
/
class String
{
public:
	String(const char* str = "")   //常类型到常类型
	{
		m_data = new char[strlen(str) + 1];
		strcpy(m_data, str);
	}
	String(const String& s)
	{
		m_data = new char[strlen(s.m_data) + 1];
		strcpy(m_data, s.m_data);
	}
	~String()
	{
		delete[]m_data;
		m_data = NULL;
	}
public:
	size_t length()const
	{
		return strlen(m_data);
	}

	char operator[](int i)
	{
		assert(i >= 0 && i < length());
		return m_data[i];
	}

	String& operator=(const String& s)
	{
		if (this != &s)
		{
			delete[](this->m_data);
			//new char[s.length() + 1];
			this->m_data = new char[s.length() + 1];  
			strcpy(this->m_data, s.m_data);
		}
		return *this;
	}

	String operator+(const String& s)
	{
		char* tmp = new char[length() + s.length() + 1];    //??????
		strcpy(tmp, this->m_data);
		strcat(tmp, s.m_data);

		String temp(tmp);
		delete []tmp;
		return temp;
	}
	
	String& operator+=(const String& s)
	{
		char* tmp = new char[strlen(this->m_data) + strlen(s.m_data) + 1];
		strcpy(tmp, this->m_data);
		strcat(tmp, s.m_data);

		delete[]m_data;
		this->m_data = tmp;
		return *this;
	}

public:
	bool operator==(const String& s)
	{
		if (strcmp(this->m_data, s.m_data) == 0)
			return true;
		return false;
	}
	bool operator!=(const String& s)
	{
		if (strcmp(this->m_data, s.m_data) != 0)
			return true;
		return false;
	}
	bool operator>(const String& s)
	{
		if (strcmp(this->m_data, s.m_data) > 0)
			return true;
		return false;
	}
	bool operator<(const String& s)
	{
		if (strcmp(this->m_data, s.m_data) < 0)
			return true;
		return false;
	}
	bool operator>=(const String& s)
	{
		if (strcmp(this->m_data, s.m_data) < 0)
			return false;
		return true;
	}
	bool operator<=(const String& s)
	{
		if (strcmp(this->m_data, s.m_data) > 0)
			return false;
		return true;
	}
private:
	char* m_data;
};


int main()
{
	String s1("Hello"); //s1[0] ==> H
	String s2("Bit.");

	s1 = s2;
	for (int i = 0; i < s1.length(); ++i)
		cout << s1[i];
	cout << endl;


	String s = s1 + s2; //s = HelloBit
	for (int i = 0; i < s.length(); ++i)
		cout << s[i];
	cout << endl;


	s1 += s2;    //

	for (int i = 0; i < s1.length(); ++i)
		cout << s1[i];
	cout << endl;

	return 0;
}

三

运算符重载之重载为成员函数：
下面的程序定义了一个简单的SmallInt类，用来表示从-128到127之间的整数。
类的唯一的数据成员val存放一个-128到127（包含-128和127这两个数）之间的整数，为了方便，
类SmallInt还重载了一些运算符。
阅读SmallInt的定义，回答题目后面的问题。

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
using namespace std;
class SmallInt;
ostream& operator<<(ostream& os, const SmallInt& si);
istream& operator>>(istream& is, SmallInt& si);

//SmallInt si(1000);

class SmallInt
{
public:
	SmallInt(int i = 0);
	//重载插入和抽取运算符
	friend ostream& operator<<(ostream& os, const SmallInt& si);
	friend istream& operator>>(istream& is, SmallInt& si);

	//重载算术运算符
	SmallInt operator+(const SmallInt& si) { return SmallInt(val + si.val); }
	SmallInt operator-(const SmallInt& si) { return SmallInt(val - si.val); }
	SmallInt operator*(const SmallInt& si) { return SmallInt(val * si.val); }
	SmallInt operator/(const SmallInt& si) { return SmallInt(val / si.val); }
	//重载比较运算符
	bool operator==(const SmallInt& si) { return (val == si.val); }
private:
	char val;
};
SmallInt::SmallInt(int i)
{
	while (i > 127)
		i -= 256;
	while (i < -128)
		i += 256;
	val = i;
}

ostream& operator<<(ostream& os, const SmallInt& si)
{
	os << (int)si.val;
	return os;
}

istream& operator>>(istream& is, SmallInt& si)
{
	int tmp;
	is >> tmp;
	si = SmallInt(tmp);
	return is;
}

int  main()
{
	SmallInt si(1000);
	cout << si << endl;
	SmallInt si1;
	cin >> si1;
	cout << si1 << endl; 
	return 0;
}

问题：（本小题4分）上面的类定义中，
重载的插入运算符和抽取运算符被定义为类的友元函数?//可以
能不能将这两个运算符定义为类的成员函数？//不能
如果能，写出函数原型，如果不能，说明理由。

语法上可以，语义上不可以代码如下：
///

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
using namespace std;

//SmallInt si(1000);

class SmallInt
{
public:
	SmallInt(int i = 0);
	//重载插入和抽取运算符
	ostream& operator<<(ostream& os)
	{
		os << (int)this->val;
		return os;
	}
	istream& operator>>(istream& is)
	{
		int tmp;
		is >> tmp;
		this->val = tmp;
		return is;
	}

	//重载算术运算符
	SmallInt operator+(const SmallInt& si) { return SmallInt(val + si.val); }
	SmallInt operator-(const SmallInt& si) { return SmallInt(val - si.val); }
	SmallInt operator*(const SmallInt& si) { return SmallInt(val * si.val); }
	SmallInt operator/(const SmallInt& si) { return SmallInt(val / si.val); }
	//重载比较运算符
	bool operator==(const SmallInt& si) { return (val == si.val); }
private:
	char val;
};
SmallInt::SmallInt(int i)
{
	while (i > 127)
		i -= 256;
	while (i < -128)
		i += 256;
	val = i;
}
int  main()
{
	SmallInt si(1000);
	si << cout << endl;
	SmallInt si1;
	si1 >> cin;
	si1 << cout << endl;
	return 0;
}

按题目要求重载，只能像知识总结中一中的那种不符合使用习惯（使用就必须如下）的重载办法

si << cout << endl;
si1 >> cin;
si1 << cout << endl;

重载为友元函数是可以的

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
using namespace std;

//SmallInt si(1000);

class SmallInt
{
public:
	SmallInt(int i = 0);
	//重载插入和抽取运算符
	friend ostream& operator<<(ostream& os, const SmallInt& s);
	friend istream& operator>>(istream& is, SmallInt& s);

	//重载算术运算符
	SmallInt operator+(const SmallInt& si) { return SmallInt(val + si.val); }
	SmallInt operator-(const SmallInt& si) { return SmallInt(val - si.val); }
	SmallInt operator*(const SmallInt& si) { return SmallInt(val * si.val); }
	SmallInt operator/(const SmallInt& si) { return SmallInt(val / si.val); }
	//重载比较运算符
	bool operator==(const SmallInt& si) { return (val == si.val); }
private:
	char val;
};
SmallInt::SmallInt(int i)
{
	while (i > 127)
		i -= 256;
	while (i < -128)
		i += 256;
	val = i;
}
ostream& operator<<(ostream& os, const SmallInt& s)
{
	os << s.val;
	return os;
}
istream& operator>>(istream& is, SmallInt& s)
{
	int tmp;
	is >> tmp;
	s.val = tmp;
	return is;
}

int  main()
{
	SmallInt si(65);
	SmallInt si1;
	cout << si<<endl;
	cin>>si1;
	cout << si1 << endl;
	return 0;
}

四

explicit关键字

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
using namespace std;
class Test
{
public:
	Test(int d = 0) : m_data(d)  	//构造函数的类型转换（隐式）Test t1;   t1 = 998;
	{
		m_count++;
	}
	~Test()
	{
		m_count--;
	}
public:
	int GetData()const
	{return this->m_data;}
public:
	operator int() //强制转换
	{
		return this->m_data;
	}
public:
	void list()
	{
		fun();
	}
	static void fun()
	{
		m_count = 10;
		cout<<"Test::fun() static"<<endl;
	}
private:
	int m_data;
	static int m_count;
};

int Test::m_count = 0; //

int main()
{
	Test t1;
	t1 = 998;
	return 0;
}

t1 = 998; //理论上我们知道普通变量是不能给对象赋值的
但是实际上构造函数不仅可以构造对象还能够隐式的做类型转换，998给对象赋值，会首先调用构造函数将整形998构造成一个匿名对象，然后用匿名对象去给对象t1赋值。

如果我们给上述代码的构造函数前加上explicit 关键字，构造函数便不能做隐式的类型转化了

explicit Test(int d = 0) : m_data(d)
{
	m_count++;
}

这样写编译就无法通过如下图：

五

哑成员

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
using namespace std;
class Test
{
public:
	Test(int d = 0) :m_data(d)
	{}
public:
	class Tmp //内部类
	{
	public:
		Tmp(int a , int b) : x(a), y(b)
		{}
	public:
		int GetX()
		{return x;}
	public:
		int x;  //
		int y;  //哑成员
	};
public:
	int m_data;
};
int main()
{
	Test T;
	cout <<"sizeof(T) = "<< sizeof(T) << endl;
	Test::Tmp tp(1,2);
	cout<<"sizeof(tp) = "<<sizeof(tp) << endl;
	return 0;
}

内部类的数据成员称为哑成员，因为实例的外部类对象的大小不包含内部类的大小，并且外部类中只能访问自己的数据成员及函数成员，无法访问内部类的任何成员

创建类中类的对象时必须加外部类的作用域访问符：
Test::Tmp tp(1,2); //创建内部类Tmp的对象时就得加外部类Test的作用域访问符Test::
创建的外部类的对象大小不带内部类