对象复制问题 && lvalue-rvalue…

2018-06-17 23:40:28来源:未知 阅读 ()

新老客户大回馈,云服务器低至5折

按值传递实参到函数和函数返回临时变量的副本,函数的效率对执行性能来说至关重要

如果避免这样的复制操作,则执行时间可能会大大缩短。

class CMessage
{
private:
    char * m_pMessage;

public:
    void showIt()const
    {
        cout << m_pMessage << endl;
    }
    //构造函数
    CMessage(const char* text = "Default message")
    {
        cout << " 构造函数" << endl;

        size_t length{ strlen(text) + 1 };
        m_pMessage = new char[length + 1];
        strcpy_s(m_pMessage, length + 1, text);
    }
    //复制构造函数
    CMessage(const CMessage & aMess)
    {
        cout << "复制构造函数" << endl;
        size_t len{ strlen(aMess.m_pMessage) + 1 };
        this->m_pMessage = new char[len];
        strcpy_s(m_pMessage, len, aMess.m_pMessage);
    }
    //重载赋值运算符
    CMessage & operator=(const CMessage & aMess)
    {
        cout << "重载赋值运算符函数" << endl;
        if (this != &aMess)
        {
            delete[]m_pMessage;
            size_t length{ strlen(aMess.m_pMessage) + 1 };
            m_pMessage = new char[length];
            strcpy_s(this->m_pMessage, length, aMess.m_pMessage);
        }
        return *this;
    }

    CMessage operator+(const CMessage & aMess)
    {
        cout <<"重载加法运算符函数" << endl;
        size_t len{strlen(m_pMessage)+strlen(aMess.m_pMessage)+1};
        CMessage message;
        message.m_pMessage = new char[len];

        strcpy_s(message.m_pMessage,len,m_pMessage);
        strcat_s(message.m_pMessage,len,aMess.m_pMessage);

        return message;
    }

    //析构函数
    ~CMessage()
    {
        cout << " 析构函数" << endl;
        delete[]m_pMessage;
    }
};
int main()
{
    CMessage motto1{ "Amiss is " };
    CMessage motto2{"as good as a mile"};
    CMessage motto3;

    motto3 = motto1 + motto2;

    motto3.showIt();
}

运行结果如下:

 构造函数            //motto1调用
 构造函数            //motto2调用
 构造函数            //motto3调用
重载加法运算符函数        
 构造函数            //operator+()中message对象调用
复制构造函数           //返回时对message对象的复制,生成message的临时副本
 析构函数            //message调用,销毁临时对象
重载赋值运算符函数        //motto3调用operator=()
 析构函数              //message的临时副本调用
Amiss is as good as a mile
 析构函数
 析构函数
 析构函数

----------------------------------------------------------------------------------------------------------------------------------------------------------------

改进方法:应用rvalue引用形参

当源对象是一个临时对象,在复制操之后立即就被销毁时,复制的替代方案是偷用由 m_pMessage 成员指向的临时对象的内存,并传送到目标对象。

如果这么做,那么不需要为目标对象分配更多的内存,不需要复制对象,也不需要释放源对象拥有的内存。

在操作完成以后将立即销毁源对象,因此这么做没有风险,只是加快了执行速度。

实现此技术的关键是检测复制操作中何时是一个 rvalue。

  CMessage(const CMessage & aMess)
  {
      cout << "复制构造函数" << endl;
      size_t len{ strlen(aMess.m_pMessage) + 1 };
      this->m_pMessage = new char[len];
      strcpy_s(m_pMessage, len, aMess.m_pMessage);
   }

  CMessage(CMessage && aMess)
   {
      cout << "" << endl;
      m_pMessage = aMess.m_pMessage;
      aMess.m_pMessage = nullptr;      //必须要这么做,防止删除原指向的内存
    }

我们知道用对象初始化当前对象、返回临时对象都会调用复制构造函数。

motto3 = motto1 + motto2;调用重载加法运算符函数后会产生临时变量 message。

而对临时变量的复制产生需要的临时副本会增加运行时间。

所以,临时变量的副本可以直接“偷用”源临时变量对象成员指向的内存。通过以上两个函数比较可知,lvalue引用形参多了复制的操作。

难道要 lvalue引用形参的形式没有用了吗?

若: motto3=motto1 时,可知必须用 lvalue 引用形参的形式。如果 rvalue 可用,将会使两个对象同时指向一块内存。

所以, rvalue 针对 临时变量。

 

可以像下面这样额外创建 operator=()函数的重载

  CMessage & operator=(CMessage && aMess)
   {
      cout <<"Move assignment operator function called." << endl;
      delete[]m_pMessage;
      m_pMessage = aMess.m_pMessage;
      aMess.m_pMessage = nullptr;       //必须要这么做,防止删除原指向的内存
      return *this;
   }

  CMessage & operator=(const CMessage & aMess)
  {
     cout << "重载赋值运算符函数" << endl;
     if (this != &aMess)
     {   delete[]m_pMessage;
        size_t length{ strlen(aMess.m_pMessage) + 1 };
          m_pMessage = new char[length];
        strcpy_s(this->m_pMessage, length, aMess.m_pMessage);
     }
     return *this;
  }

观察这两个 lvalue、rvalue引用形参重载赋值运算符函数的区别:

motto3 = motto1 + motto2;调用重载加法运算符函数后会产生临时变量 message。在函数返回时又调用 rvalue引用形参类型的复制构造函数,

产生临时对象 message 的临时副本。

之后调用重载赋值运算符函数,由于此时仍是临时对象的副本,

所以,仍可以采用“ 偷换 ”源临时变量对象成员指向的内存。而避免赋值函数对对象成员的复制。

临时对象由编译器生成,使用之后会自动调用析构函数释放。

所以此处需要我们通过观察代码运行,自己来理解。

 

  CMessage operator+(const CMessage & aMess)
   {
    cout <<"重载加法运算符函数" << endl;
    size_t len{strlen(m_pMessage)+strlen(aMess.m_pMessage)+1};
    CMessage message;
    message.m_pMessage = new char[len];

    strcpy_s(message.m_pMessage,len,m_pMessage);
    strcat_s(message.m_pMessage,len,aMess.m_pMessage);

    return message;
   }

不知道你有没想过哟,为什么上面函数没有返回引用,引用可以避免不必要的复制,不是很方便吗?

添加引用 CMessage operator+(const CMessage & aMess)

运行结果:

   构造函数
   构造函数
   构造函数
  重载加法运算符函数
   构造函数
   析构函数
  重载赋值运算符函数
请按任意键继续. . .

发现程序崩溃,运行到重载赋值运算符函数就不能继续运行了。

Why?

如果被返回的对象是被调用函数中的局部变量,则不应按引用方式返回它。

因为,在被调用函数执行完毕时,局部对象将调用其 析构函数。

 

如果函数返回一个没有公有复制构造函数的类(如 ostream 类)的对象,它必须返回指向对象的引用。

如果在类中定义了 operator=()成员函数和复制构造函数时,将形参定义为非常量 rvalue 引用,则需要确保也定义了具有 const lvalue引用形参的标准版本。

编译器会提供它们的默认版本,逐一成员的进行复制。

标签:

版权申明:本站文章部分自网络,如有侵权,请联系:west999com@outlook.com
特别注意:本站所有转载文章言论不代表本站观点,本站所提供的摄影照片,插画,设计作品,如需使用,请与原作者联系,版权归原作者所有

上一篇:HDU 5091---Beam Cannon(线段树+扫描线)

下一篇:POJ 3761 Bubble Sort 快速幂取模+组合数学