C++,当函数参数或者返回值是对象......（★firecat推荐★）

最新推荐文章于 2024-09-01 11:50:30 发布
最新推荐文章于 2024-09-01 11:50:30 发布
阅读量3.7k 收藏 2
点赞数
分类专栏： C/C++ 文章标签： 函数 对象 返回值

文章来源：http://blog.chinaunix.net/uid-20816252-id-2791683.html

如果函数的传入参数和返回值是对象，那么这个过程中会发生哪些我们未曾注意过的细节呢？

我在VS2008下做了如下实验，并做出了简单的分析，有不足或者不准确的地方，欢迎大家拍砖，我会及时修正相关内容。

一、函数的传入参数是对象。
  2. #include 
  3. #include 
  4. using namespace std;

  6. class Person
  7. {
  8. public:
  9.     Person(int nAge):m_nAge(nAge){ cout << _T("创造了一个年龄为") << m_nAge << _T("的人") << endl; }
  10.     Person(Person& Somebody):m_nAge(Somebody.m_nAge + 10) { cout << _T("复制创造了一个年龄为") << m_nAge << _T("的人") << endl; }
  11.     ~Person() { cout << _T("析构了一个年龄为") << m_nAge << _T("的人") << endl; }

  13. private:
  14.     int m_nAge;
  15. };

  17. void Test(Person Somebody)
  18. {
  19.     return;
  20. }

  22. int _tmain(int argc, TCHAR* argv[], TCHAR* envp[])
  23. {
  24.     Person Mike(20);
  25.     Test(Mike);
  26.     return 1;
  27. }
上述代码的执行结果如下：
对于上述代码做如下简单解释：
Person Mike(20);
创造了一个年龄为20的人
Test(Mike);
将Mike作为Test函数的实参传入，Person Somebody的复制构造函数被调用。
当Test函数返回后，Somebody这个对象的生命周期结束，它的析构函数被调用。
当_tmain函数返回后，Mike这个兑现的声明周期结束，它的析构函数被调用。

上述代码中存在一个比较关键的地方，那就是在调用Test函数的时候，涉及到将Mike对象拷贝给Somebody对象。

  1. #include 
  2. #include 
  3. using namespace std;

  5. class Person
  6. {
  7. public:
  8.     Person(int nAge):m_nAge(nAge){ cout << _T("创造了一个年龄为") << m_nAge << _T("的人") << endl; }
  9.     Person(Person& Somebody):m_nAge(Somebody.m_nAge + 10) { cout << _T("复制创造了一个年龄为") << m_nAge << _T("的人") << endl; }
  10.     ~Person() { cout << _T("析构了一个年龄为") << m_nAge << _T("的人") << endl; }

  12. public:
  13.     int m_nAge;

  15. };

  17. void Test(Person Somebody)
  18. {
  19.     return;
  20. }

  22. int _tmain(int argc, TCHAR* argv[], TCHAR* envp[])
  23. {
  24.     Person Mike(20);
  25.     Test(Person(50));
  26.     return 1;
  27. }
上述代码的执行结果如下：
我们可以从结果中看到，这次并没有拷贝构造函数被调用，个人猜测，Person(50)这个临时构造的对象就是Somebody这个对象，它们实际上是一个对象，存在于Test函数的栈中，至于这是C++本身的标准还是VS2008帮助我们优化之后的结果，尚未进行研究。

二、函数的返回值是对象。
  1. #include 
  2. #include 
  3. using namespace std;

  5. class Person
  6. {
  7. public:
  8.     Person(int nAge):m_nAge(nAge){ cout << _T("创造了一个年龄为") << m_nAge << _T("的人") << endl; }
  9.     Person(Person& Somebody):m_nAge(Somebody.m_nAge + 10) { cout << _T("复制创造了一个年龄为") << m_nAge << _T("的人") << endl; }
  10.     ~Person() { cout << _T("析构了一个年龄为") << m_nAge << _T("的人") << endl; }

  12. public:
  13.     int m_nAge;

  15. };

  17. Person Test()
  18. {
  19.     Person Jack(30);
  20.     return Jack;
  21. }

  23. int _tmain(int argc, TCHAR* argv[], TCHAR* envp[])
  24. {
  25.     Person Tom = Test();
  26.     return 1;
  27. }
上述代码的执行结果如下：
上述代码的简单解释：
Test函数被执行，Person Jack(30)被执行，构造函数被调用。
Person Tom = Test();Test函数执行完成之后，将Jack对象拷贝给Tom对象，所以，Tom的拷贝构造函数被执行，返回值赋值完成之后，Jack对象的生命周期结束，析构函数被执行，_tmain函数返回之后，Tom对象的生命周期结束，析构函数被执行。

  1. #include 
  2. #include 
  3. using namespace std;

  5. class Person
  6. {
  7. public:
  8.     Person(int nAge):m_nAge(nAge){ cout << _T("创造了一个年龄为") << m_nAge << _T("的人") << endl; }
  9.     Person(Person& Somebody):m_nAge(Somebody.m_nAge + 10) { cout << _T("复制创造了一个年龄为") << m_nAge << _T("的人") << endl; }
  10.     ~Person() { cout << _T("析构了一个年龄为") << m_nAge << _T("的人") << endl; }

  12. public:
  13.     int m_nAge;

  15. };

  17. Person Test()
  18. {
  19.     Person Jack(30);
  20.     return Jack;
  21. }

  23. int _tmain(int argc, TCHAR* argv[], TCHAR* envp[])
  24. {
  25.     Test();
  26.     cout << _T("-----------------------") << endl;
  27.     return 1;
  28. }
上述代码的执行结果如下：
简单的分析上述代码：
我们看到，代码中并没有定义一个对象来接受Test函数的返回值，但是系统仍然为我们创造了一个临时的对象来接受Test函数的返回值，但是因为这个临时的对象并没有被我们用到，所以，它马上就被析构了。

  1. #include 
  2. #include 
  3. using namespace std;

  5. class Person
  6. {
  7. public:
  8.     Person(int nAge):m_nAge(nAge){ cout << _T("创造了一个年龄为") << m_nAge << _T("的人") << endl; }
  9.     Person(Person& Somebody):m_nAge(Somebody.m_nAge + 10) { cout << _T("复制创造了一个年龄为") << m_nAge << _T("的人") << endl; }
  10.     ~Person() { cout << _T("析构了一个年龄为") << m_nAge << _T("的人") << endl; }

  12. public:
  13.     int m_nAge;

  15. };

  17. Person Test()
  18. {
  19.     return Person (30);
  20. }

  22. int _tmain(int argc, TCHAR* argv[], TCHAR* envp[])
  23. {
  24.     Person Tom = Test();
  25.     cout << _T("-----------------------") << endl;
  26.     return 1;
  27. }
上述代码的执行结果如下：
我们可以从结果中看到，这次并没有拷贝构造函数被调用，个人猜测，Person(30)这个临时构造的对象就是Tom这个对象，它们实际上是一个对象，存在于_tmain函数的栈中，至于这是C++本身的标准还是VS2008帮助我们优化之后的结果，尚未进行研究。

三、函数的传入参数和返回值都是对象。
  1. #include 
  2. #include 
  3. using namespace std;

  5. class Person
  6. {
  7. public:
  8.     Person(int nAge):m_nAge(nAge){ cout << _T("创造了一个年龄为") << m_nAge << _T("的人") << endl; }
  9.     Person(Person& Somebody):m_nAge(Somebody.m_nAge + 10) { cout << _T("复制创造了一个年龄为") << m_nAge << _T("的人") << endl; }
  10.     ~Person() { cout << _T("析构了一个年龄为") << m_nAge << _T("的人") << endl; }

  12. public:
  13.     int m_nAge;

  15. };

  17. Person Test(Person Somebody)
  18. {
  19.     return Somebody;
  20. }

  22. int _tmain(int argc, TCHAR* argv[], TCHAR* envp[])
  23. {
  24.     Person Mike(20);
  25.     Person Tom = Test(Mike);
  26.     return 1;
  27. }
上述代码的执行结果如下：
上述代码的简单解释如下：
Person Mike(20);
构造函数被执行

将Mike作为实参传入到Test函数当中，实参到形参的拷贝过程调用了Somebody的拷贝构造函数。

Test函数执行结束，Somebody对象被拷贝给Tom对象，调用了Tom对象的拷贝构造函数。

Somebody的生命周期结束，析构函数执行。
Tom对象的生命周期结束，析构函数被执行。
Mike对象的生命周期结束，析构函数被执行。
四、firecat实例1（函数参数是对象）
#include "stdafx.h"
#include <iostream>

using namespace std;

class Node
{
public:  
Node()
{
cout << "Node1()\n";
}
//使用默认的拷贝构造函数
int data1;
int data2;
};

void Fn(Node n)  
{
cout << n.data1;
cout << ",";
cout << n.data2;
cout << ",";
n.data1 = 3;
n.data2 = 3;
}  

int _tmain(int argc, _TCHAR* argv[])
{
Node n;
n.data1 = 1;
n.data2 = 1;
Fn(n);
cout << n.data1;
cout << ",";
cout << n.data2;
cout << endl;
return 0;
}

运行结果：

Node1()
1,1,1,1
请按任意键继续. . .

#include "stdafx.h"
#include <iostream>

using namespace std;

class Node
{
public:  
Node()
{
cout << "Node1()\n";
}
//使用自定义的拷贝构造函数
Node(Node& n);
int data1;
int data2;
};

Node::Node(Node &n)
{
cout << "Node2()\n";
}

void Fn(Node n)  
{
cout << n.data1;
cout << ",";
cout << n.data2;
cout << ",";
n.data1 = 3;
n.data2 = 3;
}  

int _tmain(int argc, _TCHAR* argv[])
{
Node n;
n.data1 = 1;
n.data2 = 1;
Fn(n);
cout << n.data1;
cout << ",";
cout << n.data2;
cout << endl;
return 0;
}
运行结果：

Node1()
Node2()
1245032,4266166,1,1
请按任意键继续. . .

总结：
    类对象做为函数参数时，是被存放在栈上的，不影响实参的数据。

    若未重写拷贝构造函数，类的其它构造函数将不会被调用。形参的数据是通过内存拷贝传递的。若重写了，拷贝构造函数将会在初始化形参时被调用，不再进行内存拷贝工作。

firecat实例2（函数返回值是对象）

#include "stdafx.h"

#include <iostream>

using namespace std;

class Node
{
public:  
Node()
{
cout << "Node1()\n";
}
//使用默认的拷贝构造函数
int data1;
};

Node Fn()  
{
Node n;
n.data1 = 1;
return n;
}  

int _tmain(int argc, _TCHAR* argv[])
{
Node f = Fn();
cout << f.data1;
cout << endl;
return 0;
}

运行结果：

Node1()
1
请按任意键继续. . .


#include "stdafx.h"

#include <iostream>

using namespace std;

class Node
{
public:  
Node()
{
cout << "Node1()\n";
}
//使用自定义的拷贝构造函数
Node(Node& n)
{
cout << "Node2()\n";
}

int data1;
};

Node Fn()  
{
Node n;
n.data1 = 1;
return n;
}  

int _tmain(int argc, _TCHAR* argv[])
{
Node f = Fn();
cout << f.data1;
cout << endl;
return 0;
}

运行结果：

Node1()
Node2()
-858993460
请按任意键继续. . .


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

参考文章：

C++愤恨者札记1——类对象作为函数参数的数据传递过程

C++愤恨者札记2——函数返回值为类对象

利白
关注
专栏目录
C++函数如何返回一个对象
szgks的博客
12-27 3799
假设我们现在希望一个函数初始化并且返回一个类： 现在有三种方式 返回指针 返回Reference 返回一个新对象 第一种　返回指针 class Rational{ ．．．．．． private: int n; } const Rational *operator+(const Rational &lhs,const Rational &rhs){ Rational *result = new Rational(lhs.n + rhs.n); //heap内构造 return *
linux c mysql连接池_mysql,redis客户端连接池和线程池的Linux C编程实现（★firecat推荐★）...
weixin_42548893的博客
01-19 232
一、环境准备：CentOS7，CMake编译器Mysql使用官方c语言版本客户端，不使用c++库，因为c++库依赖boost库Linux安装mysql时，有这个包，mysql-community-devel-5.7.18-1.el7.x86_64.rpm -- 里面内容是c语言版本的客户端库函数和头文件Redis使用自带的hiredis库，也是c语言实现CMakeLists.txtcmake_mi...
【c++】返回类对象
热门推荐
ethan_guo的博客
06-17 2万+
函数返回值是一个类对象时，有以下几种选择：1，返回对象的const引用；2，返回对象的引用；3，返回对象；4，返回const对象1，返回对象的const引用，举例：#include &lt;iostream&gt; #include &lt;cmath&gt; using namespace std; class Complx { private: double real; double ...
C++中不定参数函数的实现方法
最新发布
长弓的博客
09-01 1351
C++中实现不定参数函数可以采用多种方法，这篇文章讨论不定参数模板和va_list。
C++ —— 有关函数返回对象的说明
柚咖小窝
05-27 2076
当成员函数或独立的函数返回对象时，有几种返回方式可供选择。可以返回指向对象的引用、指向对象的 const 引用、const 对象。 返回指向 const 对象的引用 使用 const 引用的常见原因是旨在提高效率，但对于何时采用这种方法存在一些限制。如果函数返回传递给它的对象，可以通过返回引用来提高效率。例如，编写函数 Max()，它返回两个 Object 对象中较大的一个(假设 Object 类重载了比较运算符)。 // Version 1 Object Max(const Object & ob
c++ 函数返回类对象
gonaYet的博客
12-03 5555
当函数返回类对象的时候，c++编译器会进行返回值优化 返回值优化（Return value optimization，缩写为RVO）是C++的一项编译优化技术。即删除保持函数返回值的临时对象。这可能会省略两次复制构造函数，即使复制构造函数有副作用。[1] [2] 典型地，当一个函数返回一个对象实例，一个临时对象将被创建并通过复制构造函数把目标对象复制给这个临时对象。C++标准允许省略这些
C++探讨 一: 函数返回值为类对象和类对象引用
U__F__O
06-22 5701
C++ 中函数返回值为类对象的研究
java票证管理办法_java – 无法使用kerberos票证缓存对apache http client 4.5进行身份验证...
weixin_29898529的博客
02-25 503
我正在对kerberos认证的REST服务执行https请求.如果我使用keytab,一切都很好.但是,我要求我应该使用kerberos票证缓存文件,该文件是在使用其密码登录工作站时创建的.我将用MY_DOMAINE.COM替换域名所以,klist显示：Ticket cache: FILE:/tmp/krb5cc_210007Default principal: dragomira@MY_DOMA...
configure project qt_使用Qt Creator实现两台Linux电脑远程部署和调试(一台有桌面，一台无桌面)...
weixin_42556197的博客
12-24 796
序言考虑到Linux环境下编写C/C++程序，如果使用原生的Vim编程/调试比较麻烦，不利于新手使用，所以笔者尝试使用Qt实现两台Linux电脑远程部署和调试。一台有桌面，使用Qt Creator用于编辑源码调试环境，另一台无桌面，用于服务器正式环境。Qt Linux版本安装在调试机。本文以qt-opensource-linux-x64-5.7.1.run为例。Qt下载网址是：http://dow...
VS2015中QT VS TOOLS Open Qt Project file 无反应报错Cannot run compiler 'cl'. Maybe you forgot to setup the
writemans的博客
01-09 4775
用VS2015中QT VS TOOLS 的Open Qt Project file 选项打开qt工程报错 (Import): Generating new project of liteidex.pro file (qmake) : Using: C:\QT\QT5.9.1\5.9.1\MSVC2015\bin\qmake (qmake) : Working Directory: C:\
firecat-开源
07-08
Firecat 是用 Java 编写的服务器端 JavaScript（NSP）Web 服务器。 它类似于 ASP 和 JSP，但它使用 JavaScript 作为主要的脚本语言。 它可以在任何 JVM 上运行，但主要目标将是 Free Runtime，例如 SableVM、JamVM ...
C++ 返回对象
Lin的博客
11-28 1304
函数返回const 对象、引用、非const 对象
C++返回对象
weixin_42309425的博客
05-31 197
总结：函数返回对象，会进行深拷贝。返回引用或者指针则不会。无论在函数是member方法或者nonmember方法都一样。返回对象时，如果传入的参数是对象指针，则 会进行拷贝构造、等于构造、析构--why?
C++中函数返回值为对象
weixin_43731641的博客
07-06 1650
Data类 class Data { private: int a; int b; public: Data() { this->a=0; this->b=0; cout<<"无参构造"<<endl; } Data(int a,int b) { this->a=a; this->b=b; cout<&lt
C++函数返回对象探讨
凌剑的专栏
09-10 742
以下函数ReturnObjectDirect与ReturnObject分别调用了多少次构造函数？#include using namespace  std;class Base{public:    Base( )    {        cout    }    Base(const Base & other)    {        cout    }    ~Base()    {     
C++中,对象作为函数参数的几种情况
weixin_44948467的博客
10-07 5165
Passing Objects to Functions (对象作为函数参数) Objects as Function Arguments (对象作为函数参数) You can pass objects by value or by reference. (对象作为函数参数，可以按值传递，也可以按引用传递) (1) Objects as Function Return Value(对象作为函数参数) // Pass by value void print( Circle c ) { //作为函数参
c++怎么返回对象
songjian1104的专栏
11-30 2408
返回对象，无非两种方式，返回栈对象和堆对象指针，栈对象指针不能返回，因为可能使用不该使用的内存，堆对象也不能直接返回，因为会产生内存泄漏。下面，我们分析两种返回方式的优缺点，及针对缺点的解决方案。 返回栈对象： 优点：不用手动释放内存，避免了内存泄漏； 缺点：会产生对象拷贝，如果对象比较大，比如，对象里面有大数组，会产生性能开销。 返回堆对象指针： 优点：不会产生对象拷贝，对性能友好； 缺点：函数调用之后手动释放对象，代码管理难度和内存泄漏风险提高。 那有没有办...
参数为对象？
Problem_Girl的博客
01-17 327
参数为对象？ <script> functionfn2(student){ student.a=10; } varwang={name:18}; fn2(wang); console.log(wang);//wang对象就有了a=10，name：18 <...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值