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

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

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

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

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

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

  10. private:
  11.     int m_nAge;
  12. };

  13. void Test(Person Somebody)
  14. {
  15.     return;
  16. }

  17. int _tmain(int argc, TCHAR* argv[], TCHAR* envp[])
  18. {
  19.     Person Mike(20);
  20.     Test(Mike);
  21.     return 1;
  22. }
上述代码的执行结果如下:
对于上述代码做如下简单解释:
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;

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

  10. public:
  11.     int m_nAge;

  12. };

  13. void Test(Person Somebody)
  14. {
  15.     return;
  16. }

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

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

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

  10. public:
  11.     int m_nAge;

  12. };

  13. Person Test()
  14. {
  15.     Person Jack(30);
  16.     return Jack;
  17. }

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

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

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

  10. public:
  11.     int m_nAge;

  12. };

  13. Person Test()
  14. {
  15.     Person Jack(30);
  16.     return Jack;
  17. }

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

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

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

  10. public:
  11.     int m_nAge;

  12. };

  13. Person Test()
  14. {
  15.     return Person (30);
  16. }

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

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

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

  10. public:
  11.     int m_nAge;

  12. };

  13. Person Test(Person Somebody)
  14. {
  15.     return Somebody;
  16. }

  17. int _tmain(int argc, TCHAR* argv[], TCHAR* envp[])
  18. {
  19.     Person Mike(20);
  20.     Person Tom = Test(Mike);
  21.     return 1;
  22. }
上述代码的执行结果如下:
上述代码的简单解释如下:
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——函数返回值为类对象

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值