条款19了解临时对象的来源练习

最新推荐文章于 2023-03-28 22:08:42 发布

HAN-Kai

最新推荐文章于 2023-03-28 22:08:42 发布

阅读量881

点赞数

CC 4.0 BY-SA版权

分类专栏： More Effective C++ C/C++

本文链接：https://blog.youkuaiyun.com/hankai1024/article/details/8130372

C/C++ 同时被 2 个专栏收录

148 篇文章

订阅专栏

More Effective C++

9 篇文章

订阅专栏

本文探讨了C++中对象的不同传递方式（如引用传递、常量引用传递等）及函数返回对象时的行为，包括临时对象的创建与销毁过程。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

例1

#include<iostream>
using namespace std;

class Base
{
      public:
             int a;
             int b;
             Base(){cout<<"base"<<endl;}
             Base(Base &b){cout<<"base(&)"<<endl;}
             ~Base(){cout<<"~base"<<endl;}
             void mf(){cout<<"B::fun()"<<endl;}
};

class Derived:public Base
{
    public:
           int c;
           Derived(){cout<<"Derived"<<endl;}
           Derived(Derived &d){cout<<"Derived(&)"<<endl;}
           ~Derived(){cout<<"~Derived"<<endl;}
           void mf(){cout<<"D::fun()"<<endl;}
};

void func(Base& d)//切割，只引用了D类中B的部分。 
{   
   cout<<sizeof(d)<<endl;
   d.mf();
   cout<<"func"<<endl;
}

int main()
{
    Derived d;
    func(d);
    getchar();
    return 0;
}

结果：

例2：

#include<iostream>
using namespace std;

class Base
{
      public:
             int a;
             int b;
             Base(){cout<<"base"<<endl;}
             Base(Base &b){cout<<"base(&)"<<endl;}
             ~Base(){cout<<"~base"<<endl;}
             void mf(){cout<<"B::fun()"<<endl;}
};

class Derived:public Base
{
    public:
           int c;
           Derived(){cout<<"Derived"<<endl;}
           Derived(Derived &d){cout<<"Derived(&)"<<endl;}
           ~Derived(){cout<<"~Derived"<<endl;}
           void mf(){cout<<"D::fun()"<<endl;}
};

void func(Derived& d) 
{   
   cout<<sizeof(d)<<endl;
   d.mf();
   cout<<"func"<<endl;
}

int main()
{
    Derived d;
    func(d);
    getchar();
    return 0;
}

结果：‘

例3：reference-to-const 参数，产生临时变量

#include<iostream>
using namespace std;

class Base
{
      public:
             int a;
             int b;
             Base(int x){cout<<"base"<<endl;}
             Base(Base &b){cout<<"base(&)"<<endl;}
             ~Base(){cout<<"~base"<<endl;}
             void mf(){cout<<"B::fun()"<<endl;}
};

void func(const Base& b) //func(Base& b)则编译不通过 
{   
   cout<<sizeof(b)<<endl;
  // b.mf();//编译不通过，b是隐式转换的临时变量时，不能调用Base的成员函数。 
   cout<<"func"<<endl;
}

int main()
{
    int x=9;
    func(1);//隐式转换。Int->Base.
    getchar();
    return 0;
}

只有当对象以by value方式传递，或是当对象被传递给一个reference to const参数时，这些转换才会发生。如果对象被传递给一个reference to no-const 参数，并不会发生此类转换。所以上例中func(Base& b)则编译不通过。

1.任何时候只要看到一个reference-to-const参数，就极可能会产生一个临时对象，绑定至该参数上。

2.任何时候只要你看到一个函数返回一个对象，就会产生临时对象（并于稍后销毁）。

例4：函数返回对象

#include<iostream>
using namespace std;

class Base
{
      public:
             Base(){cout<<"Base"<<endl;}
             Base(Base& b){cout<<"Base(&)"<<endl;}
             ~Base(){cout<<"~Base"<<endl;}
};

Base func()
{
     return Base();//编译器优化，把对象构造到目标对象上。如同Base tp = Base();
}

int main()
{
    func();//相当于const Base temp =  func();temp在函数调用语句结束后即析构。
    getchar();
    return 0;
}

结果：

例5：函数返回对象

#include<iostream>
using namespace std;

class Base
{
      public:
             Base(){cout<<"Base"<<endl;}
             Base(Base& b){cout<<"Base(&)"<<endl;}
             ~Base(){cout<<"~Base"<<endl;}
};

Base func(Base &b)
{
     return b;
}

int main()
{
	Base ob;
    func(ob);//相当于const Base temp =  func(ob);temp在函数调用语句结束后即析构。
    getchar();
    return 0;
}

结果：

例6：函数返回对象

#include<iostream>
using namespace std;

class Base
{
      public:
             Base(){cout<<"Base"<<endl;}
             Base(Base& b){cout<<"Base(&)"<<endl;}
             ~Base(){cout<<"~Base"<<endl;}
};

Base func(Base b)
{
     return b;
}

int main()
{
    Base ob;
    func(ob);//相当于const Base temp =  func(ob);temp在函数调用语句结束后即析构。
    getchar();
    return 0;
}

结果：