C++详细的各种运算符重载

1、+加运算符重载

运算符重载是为了实现对自定义数据的操作，如对自己自定义类的操作，类数据的加减，输出等等。
要求：对自己定义的person类进行加法操作。

(1)成员函数实现

class person
{
  friend  ostream &operator<<( ostream & out ,person &p);
friend void test01();//必须声明test01为类person的友元函数
friend person operator+(const person & p,int val);
public :
    //构造函数对其进行初始化，也可以使用有参数的构造函数
    person()
    {
        this ->age=15;
        this ->tight=177.5;
    }

 person operator+(const person & p)
 {
     person temp;
     temp.age=this->age+p.age;
     temp.tight=this->tight+p.tight;
     return temp;
 }
private :
    float tight;//身高
    int age;//年龄


};

(2)全局函数实现

person operator+(const person & p,int val)
{
    person temp;
    temp.age=p.age+val;
    temp.tight=p.tight*val;
    return temp;
}

备注：由于类数据是私有，必须要把全局函数设计为友元才可以进行访问

2、cout运算符重载

对输出流符号的运算符重载从何实现对自己自定义数据的输出

 ostream &operator<<( ostream & out ,person &p)
 {

     out<<p.age<<p.tight<<endl;
     return out;
 }

因为把把数据放到cout的右边，即cout<<class a,所以只能使用全局运算符重载实现，主义把其设计为类的友元，否则不可以访问private类型的数据

3、++运算符重载

++i和i++的区别，++前置加加是先加载使用，后置加加是用完后在加加

class Myinteger
 {
     //做友元输出自己定义的数据
friend ostream &operator<<( ostream & out ,Myinteger p);
public:
    Myinteger()
    {
       num=0;

    }
    //前置++ ，要返回本身，所以用this的解引用返回
    //为了实现链式编程，如果不返回引用则是实现浅拷贝
    //不满足实际的设计需求
    Myinteger &operator++()
    {

        num++;
        return *this;//返回的是引用
    }
    //为了实现后置++
  	Myinteger operator++(int) {
		//先返回
		Myinteger temp = *this; //记录当前本身的值，然后让本身的值加1，但是返回的是以前的值，达到先返回后++；
		num++;
		return temp;//返回值
	}
 private:
    int num;

 };

 //都cout运算符进行重载，从何实现输出自定义的数据

 ostream &operator<<( ostream & out ,Myinteger p)
 {

     out<<p.num;
     return out;
 }

4、赋值运算符重载

class  apple
 {
friend void test04();
 public :
    apple(int Size)
    {
        m_size=new int(Size);//在堆区开辟数据
    }
    //赋值运算符进行重载
   apple &operator=(apple & a)
    {

        if(m_size!=NULL)
        {
            delete m_size;
            m_size=NULL;

        }
         m_size=new int(*a.m_size);
         return *this;
    }
 private :
    int * m_size;
 };

备注：主义赋值运算符的深浅拷贝问题，浅拷贝值拷贝值，深拷贝是连着自己开辟区间再拷贝值深浅拷贝详情请戳一戳本处

5、测试源码

#include<iostream>
using namespace std;
#include<string>
class person
{
  friend  ostream &operator<<( ostream & out ,person &p);
friend void test01();//必须声明test01为类person的友元函数
friend person operator+(const person & p,int val);
public :
    //构造函数对其进行初始化，也可以使用有参数的构造函数
    person()
    {
        this ->age=15;
        this ->tight=177.5;
    }

 person operator+(const person & p)
 {
     person temp;
     temp.age=this->age+p.age;
     temp.tight=this->tight+p.tight;
     return temp;
 }
private :
    float tight;//身高
    int age;//年龄


};
//对于运算符的重载，可以发生函数的重载
//因为运算符本质就是函数。
person operator+(const person & p,int val)
{
    person temp;
    temp.age=p.age+val;
    temp.tight=p.tight*val;
    return temp;
}
/*******************************************
对左移运算符的重载
******************************************/
 ostream &operator<<( ostream & out ,person &p)
 {

     out<<p.age<<p.tight<<endl;
     return out;
 }

 //--------------------------------------------
 //对自加和自减 运算符的重载
 class Myinteger
 {
     //做友元输出自己定义的数据
friend ostream &operator<<( ostream & out ,Myinteger p);
public:
    Myinteger()
    {
       num=0;

    }
    //前置++ ，要返回本身，所以用this的解引用返回
    //为了实现链式编程，如果不返回引用则是实现浅拷贝
    //不满足实际的设计需求
    Myinteger &operator++()
    {

        num++;
        return *this;//返回的是引用
    }
    //为了实现后置++
  	Myinteger operator++(int) {
		//先返回
		Myinteger temp = *this; //记录当前本身的值，然后让本身的值加1，但是返回的是以前的值，达到先返回后++；
		num++;
		return temp;//返回值
	}
 private:
    int num;

 };

 //都cout运算符进行重载，从何实现输出自定义的数据

 ostream &operator<<( ostream & out ,Myinteger p)
 {

     out<<p.num;
     return out;
 }



 //-------------------------------------------
 //对赋值运算符进行重载
 class  apple
 {
friend void test04();
 public :
    apple(int Size)
    {
        m_size=new int(Size);//在堆区开辟数据
    }
    //赋值运算符进行重载
   apple &operator=(apple & a)
    {

        if(m_size!=NULL)
        {
            delete m_size;
            m_size=NULL;

        }
         m_size=new int(*a.m_size);
         return *this;
    }
 private :
    int * m_size;
 };



 //---------------------------------------------
void test01()
{

    person p1;
    person p2;
    person p3;
    p3=p1+p2;
    cout<<"age is  "<<(p1+p2).age<<"tight is "<< (p1+p2).tight<<endl;
    cout<<"重载的函数 age is "<<(p1+5).age<<"身高是 "<<(p1+5).tight<<endl;
    cout<<p3<<"nihao";
}


void test02()
{
   Myinteger myinteger;
   cout<<"++i自加后的结果是"<<++myinteger<<endl;


}
void test03()
{
   Myinteger myinteger1;
   cout<<myinteger1++<<endl;

}
void test04()
{
    apple a1(10);
    apple a2(20);
    apple a3(34);
    cout<<"a1的值为  "<<*a1.m_size<<endl;
    cout<<"a2的值为  "<<*a2.m_size<<endl;
    cout<<"a3的值为  "<<*a3.m_size<<endl;
    a1=a2=a3;
    cout<<"a1的值为  "<<*a1.m_size<<endl;
    cout<<"a2的值为  "<<*a2.m_size<<endl;
    cout<<"a3的值为  "<<*a3.m_size<<endl;
}
int main()
{
    test01();
    cout<<"-------++运算符的重载测试------"<<endl;
    test02();
    test03();
    test04();
    return 0;
}

6、总结

通过对运算符的重载可以实现对自定义数据的各种操作，满足和丰富了开发需求。