PoEduo - C++阶段班【Po学校】-Lesson03-5_运算符重载- 第7天-CSDN博客

PoEduo - Lesson03-5_运算符重载- 第7天

复习前面的知识点

空类会自动生成哪些默认函数

6个默认函数 1 构造 2 析构 3 赋值 4 拷贝构造 5 operator&（返回的是this） 6 operator*

深拷贝与浅拷贝当有指针参与的情况下，请注意维护对象属性的生命同期。

关键字 explicit 禁止函数隐式的转换

示例写一个Integer 类

#include <iostream>

class Integer
{
public:
    Integer(int num = 0):_num (num){}
    void operator = (int num)
    {
        _num = num;
    }
private:
    int _num;
};

int main()
{
    Integer demo = 10;
    demo = 100;        // 在这里拷贝赋值效率低下，因为产生临时对象，所以可以重载operator=(Integer&)

    return 0;
}

看高亮代码，引出 运算符重载

operator 运算符

除了5个不能重载，其它符号都能够重载，举例说明： “&”取地址运算符（不仅仅可以重载，它是默认生成的函数）。

五个无法重载的运算符： 1 “：：”域运算符 2 “？：”三目运算符 3 “.” 直接成员访问运算符 4 sizeof运算符 5 “*.”类成员指针运算符

运算符是有语义的，要根据对象的需求来重载运算符。

如果要连续的赋值，就要设计函数的返回值了：

#include <iostream>

class Integer
{
public:
    Integer(int num = 0):_num (num){}
    Integer& operator = (int num)
    {
        _num = num;
        return *this;
    }

    int GetNum()const
    {
        return _num;
    }
private:
    int _num;
};

int main()
{
    Integer demo ,other;
    demo = other = 100;        

    std::cout << demo.GetNum() << std::endl;


    return 0;
}

以上代码才是正常的写法，考虑到了连续=的使用情况。

看上图，充值说明连续赋值，少不了返回值，没有返回值，是不能连续赋值操作的。

如果返回值是void，那demo.operator=(other.operator(100))；里面的other.operator(100)这个函数就返回void,就会变成：demo.operator=(void);程序就出错了。改返回为Integer&，return *this;“Integer&”可以理解为默认的Integer类型的引用，它调用了默认赋值函数。代码在Integer& operator=(int num)这个函数里面加一个输出：

Integer& operator = (int num)
    {
        std::cout << "Integer& operator = (" << num << ")" << std::endl;
        _num = num;
        return *this;
    }

运行：

进一步的验证，确实调用了operator=函数，那么返回Integer&这时候调用了默认赋值，是这样子的么，再来把默认赋值也写上：

    Integer& operator = (const Integer& other)
    {
        std::cout << "Integer& operator = (默认赋值函数被调用……)" << std::endl;
        _num = other._num;
        return *this;
    }

    Integer& operator = (int num)
    {
        std::cout << "Integer& operator = (" << num << ")" << std::endl;
        _num = num;
        return *this;
    }

对比上下两个operator=函数，它们的返回类型都是Integer&,下面的返回一个int值的opetatro=函数，能不能改成Int类型返回呢？

    Integer(int num = 0):_num (num){}
    Integer& operator = (const Integer& other)
    {
        std::cout << "Integer& operator = (默认赋值函数被调用……)" << std::endl;
        _num = other._num;
        return *this;
    }

    int operator = (int num)
    {
        std::cout << "Integer& operator = (" << num << ")" << std::endl;
        _num = num;
        return _num;
    }

运行：

改了代码，程序能够正确运行，但程序的语义不对版本，类型和我们期望的类型不一致了。我要一个越南新娘，你给我返回了一个“东莞退休”的。并不是我们想要的。

所以operator=函数，返回的一定是我们当前对象的引用。

重载operator+=

#include <iostream>

class Integer
{
public:
    Integer(int num = 0):_num (num){}
    Integer& operator = (const Integer& other)
    {
        std::cout << "Integer& operator = (默认赋值函数被调用……)" << std::endl;
        _num = other._num;
        return *this;
    }

    Integer& operator = (int num)
    {
        std::cout << "Int operator = (" << _num << ")" << std::endl;
        _num = num;
        return *this;
    }

    Integer& operator+ (const int num)
    {
        _num += num;
        return *this;
    }

    int GetNum()const
    {
        return _num;
    }
private:
    int _num;
};

int main()
{
    Integer demo(10) ,other(20);
    demo = other = 100;    
    other = demo + 100;

    std::cout << demo.GetNum() << std::endl;


    return 0;
}

运行：

再来：如果写成demo = 100+ othter; int类型在前，就又出现问题了：这个时候，相当于这样子调用，int.operator+(other);
引出友元的概念：友元，它不属于我们当前的类，但它能调用当前类的成员。一般用来重载运算符：

friend Integer& operator+(int num,Integer& me)
    {
        me._num += num;
        return me;
    }

运行：

定义了一个Integer类型的引用友元：Integer& me,计算并接收结果后，返回友元。

demo = 100 + other +1000;这句代码会调用哪几个函数呢？

1 friend operator+ ; 2 operator+ ; 3 赋值 ; 注意“+”号的优先级。

发现上例重载+有点小问题，正常的加是不需要修改本身的，上例正确来说是“+=”的重载。

那么，正常int里面的“+”，怎么重载呢？

Integer& operator+= (const int num)
    {
        _num += num;
        return *this;
    }

    friend Integer& operator+=(int num,Integer& me)
    {
        me._num += num;
        return me;
    }

改为正常的“+”重载：

Integer operator+(const int num)
    {
        Integer temp = _num;
        temp._num += num;
        return temp;
    }

    friend Integer operator+(int num, const Integer& me)
    {
        Integer temp = me._num;
        temp._num += num;
        return temp;
        
    }

对比一下，看重载是否正确：

完全一样，成功实现+重载。

重载“++”运算符

那么，一个++它是前加加还是后++呢，我们可以用一个没参数，一个拥有参数来区别，重载实现：

先测试下子，哪个是前++，哪个是后++：

再看一段代码，有关临时对象的知识点：

#include <iostream>

class Integer
{
public:
    Integer(int num = 0):_num(num)
    {
        std::cout << "Integer(int "<<")" << _num<< std::endl;
    }

    Integer(const Integer& other):_num(other._num)
    {
        std::cout << "Integer(const Integer& other "<< " )" << _num << std::endl;
    }

    ~Integer()
    {
        std::cout << "~Integer( " << " )" << _num << std::endl;
    }

    Integer& operator = (const Integer& other)
    {
        std::cout << "Integer& operator = (默认赋值函数被调用……)" << std::endl;
        _num = other._num;
        return *this;
    }
        
    Integer& operator = (const int num)
    {
        std::cout << "Int operator = (" << _num << ")" << std::endl;
        _num = num;
        return *this;
    }

    Integer operator+(const int num)
    {
        Integer temp = _num;
        temp._num += num;
        return temp;
    }

    friend Integer operator+(int num, const Integer& me)
    {
        Integer temp = me._num;
        temp._num += num;
        return temp;
        
    }

    Integer& operator+= (const int num)
    {
        _num += num;
        return *this;
    }

    friend Integer& operator+=(int num,Integer& me)
    {
        me._num += num;
        return me;
    }

    Integer operator++(int)        //后++
    {
        Integer temp = *this;
        _num += 1;
        return temp;        
    }

    Integer& operator++()        //前++
    {
        _num += 1;
        return *this;
        
    }

    int GetNum()const
    {
        return _num;
    }
private:
    int _num;
};

Integer f1()
{
    return Integer(10);
}

Integer& f2()
{
    return Integer(20);
}

int main()
{
    Integer i1 ;
    Integer i2 ;

    i1 = f1();
    i2 = f2();

    
    return 0;
}

运行：

仔细看f1(),这是返回对象。用f10,f11 调试，看到底在哪里析构：

从调用f1开始：

再看：

创建临时对象，调用了构造函数。

还在f1()之内

f1()生命周期终结，返回对象：

跳出了f1(),回来99行的代码：i1=xxx; 此时并没有析构对象。

i1 = xxx; 调用拷贝赋值operator=

拷贝赋值operator=函数完成任务

再次跳转99行代码：i1=xxx;

到了这里，99行的i1=f1(); 才正常结束，这里要验证的是：f1()方法返回对象，它是在哪里析构的呢：返回对象，它是在赋值语句完成结束后，也就是函数的外面，99行i1= xxx; 完成结束时，才调用析构的。

再看f2()，返回引用。

f2()和f1()最大的区别：

这个调用了默认的拷贝赋值函数，是在i2 = XXX;这个时候调用的，这个时候f2()已经跳出了。而重点是：临时对象是在哪里析构的呢？它是在f2()函数跳出时，调用析构函数。问题是：如上图，在默认赋值函数中，被调用方other这个对象，在跳出f2()之时被析构，已经是不安全的了。虽然赋值的数据没有出错，但已经不安全的了，危险就来自函数f2里面，临时对象抛出了一个引用后，跳出函数，析构玩消失~！

再回头看 i1 = f1(); 这个是用f1返回一个对象，这个对象是在（i1 = XXX ;）拷贝赋值完成之后被析构的，而f2()返回的是一个对象引用，它是在跳出函数的时候就被析构的，所以，赋值语句里面，函数的返回赋值给一个对象时，函数返回一个对象的引用是不安全的。

关系运算符

bool operator==(const Integer& other)const
    {
        return _num== other._num;
    }

插入提取流运算符

"<<" ">>"

friend void operator<<(std::ostream& os,const Integer& me)
    {
        os << me._num;
    }

运行发现以上代码不可以连续的<< 现修改：

    friend std::ostream operator<<(std::ostream& os,const Integer& me)
    {
        os << me._num;
        return os;
    }

运行报错：

1>------ 已启动生成: 项目: PoEdu_Integer, 配置: Debug Win32 ------
1> main.cpp
1>e:\c_code\poedu_integer\poedu_integer\main.cpp(83): error C2280: “std::basic_ostream<char,std::char_traits<char>>::basic_ostream(const std::basic_ostream<char,std::char_traits<char>> &)”: 尝试引用已删除的函数
1> c:\program files (x86)\microsoft visual studio 14.0\vc\include\ostream(84): note: 参见“std::basic_ostream<char,std::char_traits<char>>::basic_ostream”的声明
========== 生成: 成功 0 个，失败 1 个，最新 0 个，跳过 0 个 ==========

ostream流对象，是不让新建的，只能返回一个引用

friend std::ostream& operator<<(std::ostream& os,const Integer& me)
    {
        os << me._num;
        return os;
    }

改成引用就OK了。os内部会进行改变，不能加const。

来看std::cin >>

friend std::istream& operator>>(std::istream& lhs, Integer& rhs)
    {
         lhs >> rhs._num;
        return lhs;
    }

这里Integer& rhs就不能是const.

资料查阅：链接地址www.cplusplus.com/reference/vector/vector/?kw=vector

作业：

预告，下节学习内容：友元

转载于:https://www.cnblogs.com/bing-z/p/6240398.html