码迷，mamicode.com
首页 > 编程语言 > 详细

【c++笔记十】运算符重载

时间：2015-02-02 18:18:07      阅读：282      评论：0      收藏：0      [点我收藏+]

标签：c++   运算符重载   

2015年2月1日 阴雨 周日

        今天难得休息，闲来无事就往岳麓山走了一遭，作为一个有情怀的程序猿就应该培养B格，不对，培养情操。拍了点雾凇，可以去我QQ空间看看。 

        今天笔记里要说的内容是：运算符重载。就像函数重载，运算符也可以重载。到底是什么样的重载呢？请听下回分解。哦不对，请看下面分解。

--------------------------------------分割线------------------------------------------

一．什么是运算符的重载？

         我们先一起来看一个例子。我们定义了一个类叫做Integer，来模仿int数据类型完成两个数的四则运算（+-*/）。

技术分享

         我很高兴的定义了两个Integer类型的对象a和b，让他们相加的值赋值给对象c。可是编译器给我报错了！！！编译器你这是干嘛？！加法都不让我做了吗？！

         看看编译器说了啥：它说，操作数是两个Integer类型的，没有适合他们的加法运算符！！！编译器觉得加法和Integer不适合，就不让他们在一起了（好狠心啊）

 

         所以由此我们引入今天的知识点——运算符的重载。

         和函数重载类似，运算符也能重载。重载后的运算符能根据相应的操作数的类型执行不一样的操作（函数重载也很相似，它能够根据不同的参数列表执行不一样的函数体）。

         本质上，运算符重载是一种：函数的特殊变现形式。看吧，说白了运算符重载，就和函数重载是相同道理的。如果你还不懂运算符重载，欢迎去看一看我的【c++笔记】

 

         那我们应该怎样去使用运算符的重载呢？

         在说使用方法之前，我们先来回顾一下，有哪些运算符？（别说你到现在还不懂什么叫做运算符！！！）让你一个个说出来，你肯定记不全啦。那我们先来给运算符分个类：单目运算符、双目运算符、三目运算符和特殊运算符。

         我们按照运算符的类型一一为大家讲解。

二．单目运算符的重载

         什么叫单目？就是操作数只有一个。比如我们常见的：++，--，！，~等等就是单目运算符。单目运算符也有两种形式变现：

1.#R

         运算符在操作数之前。这样的话，编译器会先去R这个对象对应的类型中找一个成员函数叫operator#()的。如果这个类中没有这个成员函数就去全局域中找一个全局函数叫operator#(R)

         从以上这段话我们可以知道，运算符重载先是找成员函数，再是找全局函数。而且函数形式比较特殊，是operator关键加上要重载的运算符的符号#。

我们先来一起写一个成员函数的运算符重载。但是写之前你要好好考虑一下这个函数的返回值问题。我们以前++运算符为例，写一下运算符重载：

#include <iostream>
using namespace std;
class Integer{
    int data;
public:
    Integer(int data=0):data(data){}
    void operator++(){
        ++data;
    }
    void show(){
        cout<<data<<endl;
    }
};
int main(){
    Integer a(10);
    ++a;
    a.show();
    return 0;
}
技术分享

 

       我们发现a对象的data值的确发生了自增。说明我们重载的自增运算符很正确嘛！

       但是，问题远远没有这么简单。我们稍作改动你再看看：

 技术分享

       我们连续对对象a做前++的时候编译器报错了：没有相应的前++运算符？这是为什么？我们一起来分析：++++a等效于++(++a)，我们看到函数：void operatot++()，表明我们对本类的对象a执行这个运算符重载的函数之后，返回是void类型。那么式子等价于++void。可想而知，++void是错误的，所以编译报错了。所以我们得考虑换一下返回值类型，用:Integer operator++()，试一试。

#include <iostream>
using namespace std;
class Integer{
    int data;
public:
    Integer(int data=0):data(data){}
    Integer operator++(){
        ++data;
    }
    void show(){
        cout<<data<<endl;
    }
};
int main()
{
    Integer a(10);
    ++++a;
    a.show();
    return 0;
}
技术分享

       函数运行很成功，没有报错。可是结果就差强人意了。怎么还是11呢？我们明明做了两次前加加啊！！！结果应该是12才对。

       我们一起回顾一下前几篇文章中提到的：拷贝构造函数（不懂的请看【c++笔记】）。如果我们的返回值类型是Integer类型的，返回出去的类型就会发生拷贝构造。++++a => ++（++a），实际上第二次++的是一个临时的Integer变量，并不是对象a本身。那么怎么解决这个问题呢？我们需要用到引用（不懂的请看【c++笔记】）！     这样我们就能确保函数返回的是对象本身了。

 技术分享

       函数一切正常，如我们预期的做了两次前++。


       如此这般，对于其他单目运算符的重载也类似。我们简单的对几个运算符进行重载。

#include <iostream>
using namespace std;
class Integer{
    int data;
public:
    Integer(int data=0):data(data){}
    Integer& operator++(){
        ++data;
  return *this;
    }
    Integer& operator!(){
        data =  !data;
return *this;
    }
    Integer& operator~(){
        data = ~data;
  return *this;
    }
    void show(){
        cout<<data<<endl;
    }
};
int main()
{
    Integer a(10);
    ++a;
    a.show();
    !a;
    a.show();
    ~a;
    a.show();
    return 0;
}
技术分享

 

那运算符写成全局函数应该怎么写呢？也很简单，把运算符重载的函数实现体写在全局域中，参数列表加上Integer类型就行了。可是问题来了：

 技术分享

       我们要对对象a的值data进行修改，可是data的值是private权限的，我们在类外更改不了啊！！！怎么办呢？这里需要引入友元函数的概念。

       什么是友元函数？它是先在类中定义非成员函数并在函数体之前加上friend关键字，让这个非成员函数成为这个类的朋友，然后这个函数就可以随意访问该类的任何权限的成员了。我们对程序稍加修改，加上友元函数：

#include <iostream>
using namespace std;
class Integer{
    int data;
public:
    Integer(int data=0):data(data){}
    void show(){
        cout<<data<<endl;
    }
    friend Integer& operator++(Integer&);
};
Integer& operator++(Integer& a){
    ++a.data;
    return a;
}
int main()
{
    Integer a(10);
    ++++a;
    a.show();
    return 0;
}
技术分享

        函数运行起来一切正常啦!

2.R#

        运算符在操作数后面的。比较典型的是：后++和后--。先去R对象对应的类型中找一个成员函数叫operator#(int)。如果没有就去全局域中找一个全局函数叫operator#(R,int)。

        我们可以发现，为了和#R相区别，重载运算符的函数参数列表多了一个哑元int，这int并不参与函数实现，只是为了告诉编译器，我这是R#！

        我们举一个后++例子来说明，后--也是类似的。

#include <iostream>
using namespace std;
class Integer{
    int data;
public:
    Integer(int data=0):data(data){}
    Integer operator++(int){
        return Integer(data++);
    }
    void show(){
        cout<<data<<endl;
    }
};
int main()
{
    Integer a(10);
    a++.show();
    a.show();
    return 0;
}

技术分享

        关于全局域中的运算符重载这里就省略了。同1。

三．双目运算符

        所谓双目，就是操作数是两个的，如：+，-，*，/都是双目运算符。

        形如：L#R。

        先去L对象对应的类型中找一个成员函数叫 operator#(R) ，如果找不到就去全局域中找一个全局函数叫operator#(L,R)，最后综合选择最优的函数调用。

        其实双目和单目的操作很类似。还是一起来看例子，我们就先来一起完成本文开篇时用的程序，完成两个Integer对象的相加操作。

#include <iostream>
using namespace std;
class Integer{
    int data;
public:
    Integer(int data=0):data(data){}
    void show(){
        cout<<data<<endl;
    }
    Integer operator+(Integer& b){
        return Integer(data+b.data);
    }
};
int main()
{
    Integer a(10);
    Integer b(20);
    Integer c=a+b;
    c.show();
    return 0;
}
技术分享 

       很简单就实现了想加的功能啦，当然全局的运算符重载函数你肯定也会自己写啦。当然运用什么样的返回值，根据你的设计需要来设计啦。一般来说两数相加减乘除都是作为右值的，如果想做为左值返回就自己修改返回的类型吧。

四．特殊的运算符

       你有没有发现，我并没有跟你讲三目运算符？是我老年痴呆了吗？还没到那个年龄啦。并不是所有的运算符都能重载的哦！！！

       那有哪些运算符不能重载呢？有：

       a) :: ，作用域运算符

       b) .  ，成员访问运算符

       c) * ，成员指针解引用运算符（我们在成员指针中提到过）

       d)sizeof ，求类型或者对象的大小

       e)typeid ，获取类型信息

       f) ？： ，三目运算符（唯一的三目运算符）

 

        而且运算符重载遵循一定的原则：

              1) 重载运算符的操作数中，至少要有一个类类型的操作数。

              2) 不能自己发明运算符，只能用已有的运算符。

              3) 不能改变运算符的运算特性。如：不能把二元运算符变为一元运算符。

 

        那还有哪些特殊的运算符，我们需要来说明一下呢？请各位看官继续往下看：

1.输入、输出运算符（>> ,<<）

       这种运算符并不是左移和右移运算符，而是我们经常使用的输

       输出运算符。它们是特殊的二元运算符。

       还记得我们说的二元运算符的形式：L#R。比如：cout<<a。

       先去L(cout)对象对应的类型(ostream&)中找一个成员函数叫做 operator<<(R)，如果找不到就去全局找一个全局函数叫 做operator<<(L,R)

       类型ostream不是我们自己写的类，而是系统已经写好的类。所以我们肯定不可以把这种运算符的重载写作成员函数。只能写做全局函数了，但是记得作为类的友元函数，这样才可以访问内部私有成员哦。

       关于这种流类型（输入输出流）的函数重载，还得注意两点：流类型不能加const修饰且流类型对象不能拷贝。 所以在定义返回值和参数列表的时候要注意了。

说了这么多，还是看例子吧：

#include <iostream>
using namespace std;
class Integer{
    int data;
public:
    Integer(int data=0):data(data){}
    void show(){
        cout<<data<<endl;
    }
    Integer operator+(Integer& b){
        return Integer(data+b.data);
    }
    friend ostream& operator<<(ostream&,Integer&);
    friend istream& operator>>(istream&,Integer&);
};
ostream& operator<<(ostream& os,Integer& a){
    os<<a.data;
    return os;
}
istream& operator>>(istream& is,Integer& a){
    is>>a.data;
    return is;
}
int main()
{
    Integer a;
    cin>>a;
    cout<<a<<endl;
    return 0;
}

 技术分享

        我们从键盘输入1234，然后输出了1234。这样，就轻松的完成了类的输入和输出了。想输出什么样的格式，你说了算！

 

2.new与delete的重载

       new和delete也能重载？！当然了。除了我们说的那五种不能重载的运算符，其他的运算符只要你看到过的，都可以重载。

       在重载之前，我们需要知道一点：new和delete的底层是通过malloc和free实现的。所以在重载之前你要知道我们得通过malloc和free来完成函数的实现。

              void*    operator new (size_t size);

              void     operator delete(void* ptr);

       以上就是就是new和delete的函数原型。我们一起来写代码看看：

#include <iostream>
#include <cstdlib>
using namespace std;
class Integer{
    int data;
public:
    Integer(int data=0):data(data){}
    void show(){
        cout<<data<<endl;
    }
    static void* operator new(size_t size){
        cout<<"size:"<<size<<endl;
        return malloc(size);
    }
    static void operator delete(void* ptr){
        cout<<"这是重载的delete运算符！"<<endl;
        free(ptr);
    }
};
int main()
{
    Integer* a = new Integer();
    delete a;
    return 0;
}
技术分享

3.赋值运算符“=”

       其实重载“=”的实现很好写，但是我们还应该更加关注牵涉到的内存问题。我们回想一下为什么我们需要拷贝构造函数？就是为了保证内存的独立性。其实，赋值运算符同样需要考虑这个问题。

       比如，你把一个含有分配了堆内存的对象赋值给另外一个对象时，他们的成员指针不能简单的指向相同的堆内存地址，需要自己额外申请一片堆内存。

       我们还是写个代码：

#include <iostream>
using namespace std;
class Integer{
    int* data;
    int size;
public:
    Integer(int size=1):size(size){
        data = new int[size];
        for(int i=0;i<size;i++)
            data[i]=i+1;
    }
    void show(){
        for(int i=0;i<size;i++)
            cout<<data[i]<<" ";
        cout<<endl;
    }
    Integer& operator=(Integer& a){
        size=a.size;
        data=new int[size];
        for(int i=0;i<size;i++)
            data[i]=a.data[i];
    }
    ~Integer(){
        delete[] data;
    }
};
int main()
{
    Integer a(10);
    a.show();
    Integer b;
    b = a;
    b.show();
    return 0;
}
技术分享

        我们把a赋值给b，不仅需要让b重新new一块内存出来，还要把a中的数据赋值给b。

 

4.（）圆括号运算符

        回想我们在哪里用到过（）与那算符？

        一个是函数的参数列表用到了“（）”，还有进行强制类型转换的时候也用到了“（）”。所以“（）”有两种重载功能。

1）像一个函数一样去使用一个对象

 

#include <iostream>
using namespace std;
class XiaoMi{
    int price;
public:
    XiaoMi(int price):price(price){}
    int operator()(int number){
        return number*price;
    }
};
int main()
{
    XiaoMi note(2299);
    cout<<note(10)<<endl;
    return 0;
}
技术分享

       我新建了一个XiaoMi类，并创建了一个note对象（小米note2299，给它赋个初始价格）。在成员函数中，我们重载了“（）”运算符，想给对象一个数量就能给我们返回一个总价出来。

       “老板！来10台小米note！”，“好勒，客官一共22990元，欢迎下次光临！”（自己YY）

2）将当前对象转换成其他数据类型

      这种方法的重载函数的写法有点特殊：operator 转换成的类型（）{}

      OK,我们看代码：

#include <iostream>
using namespace std;
class XiaoMi{
    double price;
    int number;
public:
    XiaoMi(double price=0.0,int number=0):price(price),number(number){}
    operator double(){
        return price;
    }
    operator int(){
        return number;
    }
};
int main()
{
    XiaoMi note(2299.5,10);
    cout<<(double)note<<endl;
    cout<<(int)note<<endl;
    return 0;
}
技术分享 

       XiaoMi类中有double类型的价格price，还有int类型的数量number。通过重载“（）”，我们如果把对象强制类型转换成double型的话，就返回price，转换成int的话就返回数量。

 

5.->和*，指针运算符

       重载他们的目的：是把一个不是指针的类型，当做指针类型来使用。

       在说这个重载之前，我还想给大家普及一个知识点——智能指针（auto_ptr）。智能指针是一种系统已经写好的类，我们一起看看c++帮助手册中对它的介绍：

 技术分享

       其实看完这个，你就知道怎么去使用它了。但是我们为什么要使用智能指针呢？我来考你一个问题：如果你动态创建了一个类的对象*a，如果你把delete它，你说它会自动调用自己的析构函数吗？会不会我们看代码：

#include <iostream>
using namespace std;
class A{
public:
    A(){
        cout<<"A()"<<endl;
    }
    ~A(){
        cout<<"~A()"<<endl;
    }
};
int main()
{
    A *a = new A();
    return 0;
}
技术分享

       细心的观察， 它并没有自动调用自己的析构函数！！！如果这个类中有自己申请的堆内存，可是你动态创建了这个对象又没有去调用它的析构函数，那么造成了内存溢出怎么办？！考虑到有犯这种粗心的人，所以就有了智能指针这个东西。智能指针会自动帮你析构函数~妈妈再也不用担心内存溢出了！

       C++帮助文档那个例子就是个很好的例子，你可以自己动手敲一敲看看是不是真的那么好用。因为我们不是专门讲智能指针的，所以回到主题来：->和*的重载。

       我们通过手动来实现智能指针的功能来为大家更好的讲解“->和*的重载”。

#include <iostream>
using namespace std;
class A{
public:
    A(){
        cout<<"A()"<<endl;
    }
    void show(){
        cout<<"A::show()"<<endl;
    }
    ~A(){
        cout<<"~A()"<<endl;
    }
};
class autoPtr{
    A *data;
public:
    autoPtr(A* data=NULL):data(data){}
    ~autoPtr(){
        delete data;
    }
    void showPtr(){
        cout<<"showPtr()"<<endl;
    }
    A* operator->(){
        return data;
    }
    A operator*(){
        return *data;
    }
};
int main()
{
    A *a = new A();
    a->show();
 
    autoPtr ap(a);
    ap.showPtr();
 
    ap->show();
    (*ap).show();
    return 0;
}<span style="background-color: rgb(255, 255, 255); font-family: Arial, Helvetica, sans-serif;"> </span>

技术分享

我们在类autoPtr中重载了“->和*”，使得autoPtr的对象ap表现的像一个指针，达到了智能指针的作用。

 

6.[ ]下标运算符

这种运算符一般用在数组的取值上。看一个简单的程序你就懂怎么去使用了：

#include <iostream>
using namespace std;
class Array{
    int* data;
    int size;
public:
    Array(int size=0):size(size){
        data = new int[size];
        for(int i=0;i<size;++i)
            data[i] = i+1;
    }
    int operator[](int flag){
        return data[flag];
    }
};
int main()
{
    Array arr(10);
    cout<<arr[5]<<endl;
    return 0;
}
技术分享 

 

------------------------------------结束语--------------------------------------

       今天我们主要讲解了：单目运算符、双目运算符和特殊运算符的重载（>>和<<,new和delete(),=，(),->和*，[ ]）。还介绍了五种不能重载的运算符，告诉了大家运算符重载的三条原则。希望大家看完这篇文章之后，能学到很多知识！

       最后，给大家布置一个作业：

       设立一个数组类，能动态决定数组的大小（重键盘输入）。能对数组进行输入、输出，能完成数组类的两个对象之间的各种运算操作：

+ - * = ！ ~  ++  --。能运用[ ]取对象中的值。当然你还可以扩展其他功能，灵活运用本文说提到的所有知识点。

       写好之后我们可以相互交流一下，我的QQ137332024。

 

【c++笔记十】运算符重载

标签：c++   运算符重载   

原文地址：http://blog.csdn.net/zmyoukonw/article/details/43409373
踩
(0)
赞
(0)
   
举报
评论 一句话评论（0）
登录后才能评论！
分享档案
更多>
2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)
周排行
mamicode.com排行更多图片
更多
友情链接
兰亭集智   国之画   百度统计   站长统计   阿里云   chrome插件   新版天听网
关于我们 - 联系我们 - 留言反馈
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码！