c++学习（运算符重载）

运算符重载

1.加号运算符重载

#include<iostream>
#include<string>
using namespace std;
class persion{
public:
  persion(){
    m_a=10;
    m_b=20;
  }
  //1.成员函数实现运算符重载
  // persion operator+(persion &p){     
  //   persion temp;
  //   temp.m_a+=p.m_a;
  //   temp.m_b+=p.m_b;
  //   return temp;
  // }

  /*
   persion persionADDpersion(persion &p){运算符重载的实质就是成员函数名的更换
    persion temp;
    temp.m_a+=p.m_a;
    temp.m_b+=p.m_b;
    return temp;
  }
  */

  int m_a;
  int m_b;
};

// 2.全局函数的运算符重载
persion operator+(persion p1,persion p2){
  persion temp;
  temp.m_a=p1.m_a+p2.m_a;
  temp.m_b=p1.m_b+p2.m_b;
  return temp;
}

persion operator+(persion p1,int num){
  persion temp;
  temp.m_a=p1.m_a+num;
  temp.m_b=p1.m_b+num;
  return temp;
}

int main()
{
  persion p1;
  persion p2;
  persion p3=p1+p2;

  //成员函数实现运算符重载的实质
  //persion p3=p1.operator+(p2);

  //全局函数实现运算符重载的实质
  //persion p3=operator+(p1,p2);

  //运算符重载实质就是函数，因此可以发生函数重载
  persion p4=p1+100;

}

2.左移运算符重载

#include<iostream>
#include<string>
using namespace std;
class persion{
  friend ostream& operator<<(ostream& cout,persion &p1);//采用友元的方式访问私有权限数据
public:
  persion(){
    m_a=10;
    m_b=20;
  }

private:
  int m_a;
  int m_b;
};
//只能利用全局函数实现左移运算符的重载
ostream& operator<<(ostream& cout,persion &p1){//由于ostream这个类对象只能有一个，
                                                //不能创建一个新的对象，因此全部采用引用的方式来进行传递
      cout<<p1.m_a<<" "<<p1.m_b;
      return cout;
}

int main()
{
  persion p1;
  cout<<p1<<endl;

}

3递增运算符重载

#include<iostream>
using namespace std;


class MyInteger{
	friend ostream& operator<<(ostream& cout, MyInteger myinteger);
public:
	MyInteger() {
		m_a = 0;
	}
	//前置运算符重载
	MyInteger& operator++() {
		m_a++;
		return *this;
	}

	//后置运算符重载
	MyInteger operator++(int) {//利用int占位符来区分前置和后置，而且只能用int来区分
		
		//先存储之前的结果
		MyInteger temp;
		temp = *this;//*this就是其本身
		//++
		m_a++;
		//返回之前的结果
		return temp;
	}

private:
	int m_a;	
};

ostream& operator<<(ostream& cout, MyInteger myinteger) {
	cout << myinteger.m_a;
	return cout;
}

int main() {
	MyInteger a;
	
	cout << a << endl;
	cout << ++a << endl;
	cout << a++ << endl;
	cout << a << endl;


}

4赋值运算符重载（深拷贝，浅拷贝问题）

#include<iostream>
using namespace std;

class persion {

public:
	persion(int age) {
		m_age = new int(age);
	}

	~persion() {
		delete m_age;
	}
	persion& operator=(persion& p){//返回值为persion&，实现程序可以连=操作，
		//先判断是否有数据开辟在堆空间
		if (m_age != NULL) {
			delete m_age;
		}
		m_age = new int(*p.m_age);
		return *this;
	}
	int* m_age;
};


int main() {
	persion p1(10);
	persion p2(20);
	persion p3(30);



	p3=p2 = p1;
	cout << *p1.m_age << endl;
	cout << *p2.m_age << endl;
	cout << *p3.m_age << endl;


}

关系运算符重载和上述差不多

函数调用重载（仿函数）

#include<iostream>
using namespace std;

class myprintf {
public:
	void operator()(string str) {
		cout << str << endl;
	}
};
class myadd {
public:
	int operator()(int num1,int num2) {
		return num1 + num2;
	}
};


int main() {
	myadd madd;
	cout << madd(10, 20) << endl;//仿函数和普通函数调用差不多

	cout << myadd()(30, 40) << endl;//匿名函数调用，匿名函数对象创建（使用完一次就释放内存，对象不存在）


}