c++ 操作符重载(一元 、二元操作符）

  运算符号重载
 2中方法：  全局函数、成员函数
 一元运算符重载  ：前置 ++  前置--  后置++   后置--
 二元运算符重载  ：+ -

c++ 中不能使用友员函数重载运算符有：=   ()   []   ->

使用有元全局函数、成员函数实现运算符重载:

#include "stdafx.h"
#include <iostream>
#include "string.h"

#pragma warning(disable:4996)

using namespace std;

class Complex{
private :
	int a;
public:
	Complex(int a = 0){
		this->a = a;
	}
	void printA(){
		cout << "value: " << this->a << endl;
	}
	//c1+c2
	friend Complex operator+(Complex& c1, Complex& c2);
	// c1-c2
	Complex operator-(Complex &c2){
		Complex temp(this->a - c2.a);
		return temp;
	}
	// ++c1
	friend Complex& operator++(Complex& c1); 
	// --c1
	Complex& operator--(){
		this->a--;
		return (*this);
	}
	//c1--
	Complex& operator--(int){
		Complex temp = *this;
		this->a--;
		return temp;
	}
	// c1++  , 后置++和前置++函数原型相同,c++编译器解决方法在后面加int
	friend Complex& operator++(Complex& c1,int);
};
// 语法： 全局函数  operator+操作符(重载参数)
Complex operator+(Complex& c1, Complex& c2){
	Complex temp(c1.a + c2.a);
	return temp;
}
Complex& operator++(Complex& c1) {
	c1.a++;
	return c1;
}
Complex& operator++(Complex& c1, int){
  // 后置++，首先返回在++
	Complex temp = c1;
	c1.a++;
	return temp;
}
int _tmain(int argc, _TCHAR* argv[])
{
	Complex c1(100);
	Complex c2(200);
	// 1. 全局函数实现+ 重载     首先把函数原型写出来
//	Complex c3 = operator+(c1, c2);  //运算符重载的本质是函数
	Complex c3 = c1 + c2;
	c3.printA();   //300

	// 2. 成员函数 实现 +    函数原型
	// c1.operator+(c2)
	// Complex operator+(Complex &c2)
	Complex c4 = c1 - c2;
	c4.printA();    //-100
	

	//		前置++  全局有元函数
	// Complex& operator++(Complex& c1)
   	++c4; 
	c4.printA();    // -99

	// 前置 --  成员函数
	 // c1.operator--    c1是this指针
	--c4;          // -100
	c4.printA();

	// 后置++    有元全局函数
	c4++;       // -99
	c4.printA();

	// 后置--   成员函数
	// c1.operator()--
	c4--;      // -100
	c4.printA();

	getchar();
	return 0;
}

2. 只能使用有缘全局函数重载案例

 

#include "stdafx.h"
#include <iostream>
#include "string.h"

#pragma warning(disable:4996)

using namespace std;
class Complex1{
private:
	int a;
public:
	Complex1(int a = 0){
		this->a = a;
	}
	void printA(){
		cout << "value: " << this->a << endl;
	}
	friend ostream& operator<< (ostream& out, Complex1& c1);
};
ostream& operator<< (ostream& out, Complex1& c1){
	out << c1.a << endl;  // endl表示换行的意思
	return out;       // 链式编程，返回引用
}


int _tmain(int argc, _TCHAR* argv[])
{   
	
	/*
	 *   重载cout << c1 
	    如果使用成员函数重载，那么 在cout.operator<<(c1) 在osstream类 中添加成员，不行，osstram是系统提供了
		全局函数： osstream& operator<< （ostream& os,Complex &c)
	 */

	Complex1 c1(100);
	Complex1 c2(200);
	cout << c1 << c2;

	getchar();
	return 0;
}

 重载=号操作符号

//先释放Obj3旧的内存
//2 根据obj1分配内存大小
//把obj1赋值

class  Name
{
public:
	Name(const char *myp)
	{
		m_len = strlen(myp);
		m_p = (char *)malloc(m_len + 1); //
		strcpy(m_p, myp);
	}

	//Name obj2 = obj1;
	//解决方案: 手工的编写拷贝构造函数 使用深copy
	Name(const Name& obj1)
	{
		m_len = obj1.m_len;
		m_p = (char *)malloc(m_len + 1);
		strcpy(m_p, obj1.m_p);
	}

	//obj3 = obj1;  // C++编译器提供的 等号操作 也属 浅拷贝
	//obj3.operator=(obj1)

	Name& operator=(Name &obj1)
	{
		//先释放旧的内存
		if (this->m_p != NULL)
		{
			delete[] m_p;
			m_len = 0;
		}
		//2 根据obj1分配内存大小
		this->m_len = obj1.m_len;
		this->m_p = new char [m_len+1];
		
		//把obj1赋值
		strcpy(m_p, obj1.m_p);
		return *this;
	}

	~Name()
	{
		if (m_p != NULL)
		{
			free(m_p);
			m_p = NULL;
			m_len = 0;
		}
	}
protected:
private:
	char *m_p;
	int m_len;
};

//对象析构的时候 出现coredump
void objplaymain()
{
	Name obj1("abcdefg");
	Name obj2 = obj1;  //C++编译器提供的 默认的copy构造函数  浅拷贝
	Name obj3("obj3");

	obj3 = obj1;  // C++编译器提供的 等号操作 也属 浅拷贝
	//obj3.operator=(obj1)
	//operato=(Name &obj1)

	// 操作符重载返回 Name& operator= ，支持链式操作
	obj1 = obj2 = obj3;
	//obj2.operator=(obj3);
	//obj1 = void;
}

void main()
{
	objplaymain();
	cout << "hello..." << endl;
	system("pause");
	return;
}