C++ 操作符重载

摘自：c++教程网视频教程 23-25讲

规则

运算符重载不允许发明新的运算符。
不能改变运算符操作对象的个数。
运算符被重载后，其优先级和结合性不会改变。
不能重载的运算符：

作用域解析运算符 ::

条件运算符 ? :

直接成员访问运算符 .

类成员指针引用的运算符 .*

sizeof运算符 sizeof

一般情况下，单目运算符最好重载为类的成员函数；双目运算符则最好重载为类的友元函数。
以下一些双目运算符不能重载为类的友元函数：=、()、[]、->。
类型转换运算符只能以成员函数方式重载
流运算符只能以友元的方式重载

格式

成员函数原型的格式：

函数类型 operator 运算符(参数表);
成员函数定义的格式：
函数类型 类名::operator 运算符(参数表){
函数体;
}
友元函数原型的格式：
friend 函数类型 operator 运算符(参数表);
友元函数定义的格式：
friend 函数类型 类名::operator 运算符(参数表){
函数体;

}

加加运算符重载++

前置++运算符重载
成员函数的方式重载，原型为：
函数类型 & operator++();
友元函数的方式重载，原型为：

friend 函数类型 & operator++(类类型 &);

后置自增和后置自减的重载
成员函数的方式重载，原型为：
函数类型 & operator++(int);
友元函数的方式重载，原型为：

friend函数类型 & operator++(类类型 &,int);

赋值运算符=

声明/原型

StrBad& operator=(const StrBad& str);

实现

StrBad& StrBad::operator=(const StrBad& str) {
	std::cout << "StrBad& StrBad::operator=(const StrBad& str)" << std::endl;
	delete value;
	init(str.value);
	return *this;
}
void StrBad::init(const char* _value) {
	int len = 1 + strlen(_value);
	value = new char[len];
	strcpy(value, _value);
}

关系运算符

bool String::operator!() const
{
	return strlen(str_) != 0;
}

中括号运算符

const char& String::operator[](unsigned int index) const
{
	return str_[index];
}

char& String::operator[](unsigned int index) const
{
	return str_[index];
}

提供返回const和非const两种
以可以接收const 和非const两种String

流运算符重载

friend istream& operator>>(istream&, 类类型&);

friend ostream& operator<<(ostream&, const 类类型&);

operator new、operator delete

void* operator new(size_t size)
void operator delete(void* p)
void operator delete(void* p, size_t size)
void* operator new(size_t size, const char* file, long line)
void operator delete(void* p, const char* file, long line)


void* operator new[](size_t size)
void operator delete[](void* p)

void operator delete[](void* p, size_t size)

#include <iostream>
using namespace std;



class Test
{
public:
	Test(int n) : n_(n)
	{
		cout<<"Test(int n) : n_(n)"<<endl;
	}
	Test(const Test& other)
	{
		cout<<"Test(const Test& other)"<<endl;
	}
	~Test()
	{
		cout<<"~Test()"<<endl;
	}

	void* operator new(size_t size)
	{
		cout<<"void* operator new(size_t size)"<<endl;
		void* p = malloc(size);
		return p;
	}

	void operator delete(void* p)
	{
		cout<<"void operator delete(void* p)"<<endl;
		free(p);
	}

	void operator delete(void* p, size_t size)
	{
		cout<<"void operator delete(void* p, size_t size)"<<endl;
		free(p);
	}

	void* operator new(size_t size, const char* file, long line)
	{
		cout<<file<<":"<<line<<endl;
		void* p = malloc(size);
		return p;
	}

	void operator delete(void* p, const char* file, long line)
	{
		cout<<file<<":"<<line<<endl;
		free(p);
	}

	void operator delete(void* p, size_t size, const char* file, long line)
	{
		cout<<file<<":"<<line<<endl;
		free(p);
	}

	void* operator new(size_t size, void* p)
	{
		return p;
	}

	void operator delete(void *, void *)
	{
	}

	int n_;
};

void* operator new(size_t size)
{
	cout<<"global void* operator new(size_t size)"<<endl;
	void* p = malloc(size);
	return p;
}

void operator delete(void* p)
{
	cout<<"global void operator delete(void* p)"<<endl;
	free(p);
}

void* operator new[](size_t size)
{
	cout<<"global void* operator new[](size_t size)"<<endl;
	void* p = malloc(size);
	return p;
}

void operator delete[](void* p)
{
	cout<<"global void operator delete[](void* p)"<<endl;
	free(p);
}

int main(void)
{
	Test* p1 = new Test(100);	// new operator = operator new + 构造函数的调用
	delete p1;

	char* str = new char[100];
	delete[] str;

	char chunk[10];

	
	Test* p2 = new (chunk) Test(200);	//operator new(size_t, void *_Where)
										// placement new，不分配内存 + 构造函数的调用
	cout<<p2->n_<<endl;
	p2->~Test();						// 显式调用析构函数

	//Test* p3 = (Test*)chunk;
	Test* p3 = reinterpret_cast<Test*>(chunk);
	cout<<p3->n_<<endl;



#define new new(__FILE__, __LINE__)
	//Test* p4 = new(__FILE__, __LINE__) Test(300);
	Test* p4 = new Test(300);
	delete p4;

	return 0;
}