c++的类(二)运算符重载

概念:运算符只能运算内置的数据类型，不能运算自定义的数据类型(类)，所以赋予运算符一个新的意义(即重载运算符，调用函数)。

一、+重载

class Person

{

public:

           Person(int age)

           {

                  this->age = age;

            }

            int age;

};

void test()

{

        Person p1(10);

        Person p2(20);

        Person p3=p1+p2;  //自定义数据类型，运算符重载，调用函数

}

p3=p1+p2实现函数:(非重载)

1.全局函数:

Person add( const Person &p, const Person &q)

{

        Person res(p.age+q.age);

        return res;

}

调用时:p3= add(p1,p2);

2. Person类内的函数(public):

Person add( const Person &p)

{

        Person res(this.age+p.age);

        return res;

}

调用时:p3=p1.add(p2);

重载:(自动调用)

把add换成operator+

二、<<重载

cout<<p1;   //不能打印，原意是要打印p1.age

//重载调用operator<<(cout，p1);

//或者cout.operator<<(p1);

重载:

全局函数

//若此时age为private，则需要将函数声明为Person类的友元

void operator<<(iostream & cout, const Person &p)

{

           cout<<p.age;  //若要endl，则要把cout返回。

}

三、自加自减重载

//有++p或p++

1.++p1重载;

//原意是p1. age++

//重载调用operator++(p1);

//或者p1. operator++();

Person& operator++()

{

          this->age =this->age+1;

          return *this;

}

cout << ++p << endl

2.p1++重载

//原意是返回原值输出cout，原值+1

//函数与++p1的区别在占位符

Person &operator++(int)

{

         Person tmp=*this;

        this->age=this->age+1;

         return tmp;

}

四、*和->重载

智能指针:new出来的空间随着函数结束释放掉

class Smartpointer

{

public:

           Smartpointer(Person *p)

           {

                     this->p=p;

           }

            ~Smartpointer()

           {

                     delete p;

           }

           

           Person *p;

};

产生重载

void test()

{

           Person *p=new Person(10);

           Smartpointer sp(p);  //引用智能指针对象sp

           cout<< p->age <<endl;

           cout<< sp->age <<endl;  //让sp->返回的是p，调用sp.operator->()

           cout<< (*sp).age <<endl; //让*sp返回的是*p，调用sp.operator*()

}

在Smartpointer类内定义重载函数

Person * operator->()

{

       return p;

}

Person& operator*()

{

        return *p;

}

//返回对象，引用(不会产生新对象)

//返回指针，指针

五、=重载

Person p1(10，"bob");

Person p2;      //无参构造

p2=p1;       //并非调用拷贝构造(旧对象初始化新对象，两者皆为旧对象)，内置了一个person& operator=( Person &p);进行浅拷贝，若有内存管理，会发生错误，所以要重写为深拷贝

重写重载函数

person &operator=( Person &p)

{

         this->age= p.age;

         this->name = new char[strlen(p.name)+1];

         strcpy(this-name, p.name);

         return *this;

}

编译器为每个类提供了4个默认函数

1. 无参构造
2. 拷贝构造
3. 析构
4. operator=();

六、==、!=重载

Person p1(10);

Person p2(10);

if(p1==p2)    //发生重载，调用p1.operator==(p2)

     cout<< " p1==p2" <<endl;

if(p1!=p2)    //发生重载，调用p1.operator==(p2)

     cout<< " p1!=p2" <<endl;

在Person类内定义重载函数:

bool operator==(Person p)

{

        return this->age==p.age; 

}

!=号同理。

七、()重载

class Person

{

public:

           add(int a, int b)

           {

                  return a+b;

           }

}

void test()

{

        Person p;

        cout<< p.add(3,4) <<endl;

        cout<< p(3,4) <<endl;   // 发生重载p.operator()(3,4),即为函数对象(可以像函数调用一样的对象)

}

在Person类内定义重载函数:

int operator()(int a,int b)

{

       return a+b;

}

即可:

cout<< Person () (3,4)<< endl;   //Person()为匿名对象Person() (3,4)为函数匿名对象

八、总结