技术教程 PoEduo - C++阶段班【Po学校】-Lesson03-5_运算符重载- 第7天 正文

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

2022-11-21,,,









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








复习前面的知识点


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


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


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


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




示例  写一个Integer 类


#include <iostream>

class Integer

{

public:

    Integer(int num = ):_num (num){}

    void operator = (int num)

    {

        _num = num;

    }

private:

    int _num;

};

int main()

{

    Integer demo = ;

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

    return ;

}


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


operator  运算符


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


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


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


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


#include <iostream>

class Integer

{

public:

    Integer(int num = ):_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 = ;        

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

    return ;

}


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




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


如果返回值是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 = ):_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 = ):_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() ,other();

    demo = other = ;

    other = demo + ;

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

    return ;

}


运行：




再来：如果写成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 = ):_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 += ;

        return temp;

    }

    Integer& operator++()        //前++

    {

        _num += ;

        return *this;

    }

    int GetNum()const

    {

        return _num;

    }

private:

    int _num;

};

Integer f1()

{

    return Integer();

}

Integer& f2()

{

    return Integer();

}

int main()

{

    Integer i1 ;

    Integer i2 ;

    i1 = f1();

    i2 = f2();

    return ;

}


运行：




仔细看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














作业：














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








 

 

  


PoEduo - C++阶段班【Po学校】-Lesson03-5_运算符重载- 第7天的相关教程结束。








《PoEduo - C++阶段班【Po学校】-Lesson03-5_运算符重载- 第7天.doc》


下载本文的Word格式文档，以方便收藏与打印。
























Copyright 2023. 昆居客 - IT编程,互联网信息技术文档大全!