Article source: blog.chinaunix.net/uid-2081625…
If the function’s passing arguments and return values are objects, what details can happen that we haven’t noticed?
I have done the following experiments in VS2008 and made a simple analysis. If there are any deficiencies or inaccuracies, you are welcome to clap bricks. I will correct the relevant content in time.
\
The function is passed an object.
-
#include \
-
#include \
-
using namespace std; \
-
\
-
class Person\
-
{
\
-
public:\
-
Person (int nAge) : m_nAge (nAge) {cout < < _T (” created an age of “) < < < < m_nAge _T (” “) < < endl; } \
-
Person(Person& Somebody):m_nAge(Somebody. M_nAge + 10) {cout << _T(” copy creates an age of “) << _T(” Person “) << endl; } \
-
~ Person () {cout < < _T (” destructor an age of “) < < < < m_nAge _T (” “) < < endl; } \
-
\
-
private:\
-
int m_nAge;
-
}; \
-
\
-
void Test(Person Somebody)\
-
{
\
-
return; \
-
} \
-
\
-
int _tmain(int argc, TCHAR* argv[], TCHAR* envp[])\
-
{
\
-
Person Mike(20); \
-
Test(Mike); \
-
return 1; \
-
}
The result of the above code is as follows:
Here is a brief explanation of the above code:
Person Mike(20);
You create a person whose age is 20
Test(Mike); Mike is passed as an argument to the Test function, and the Person Somebody copy constructor is called.
When the Test function returns, the life of the Somebody object ends and its destructor is called.
When _tmain returns, Mike’s declaration cycle ends and its destructor is called.
\
One key aspect of the above code is that the Test call involves copying the Mike object to the Somebody object.
\
-
#include \
-
#include \
-
using namespace std; \
-
\
-
class Person\
-
{
\
-
public:\
-
Person (int nAge) : m_nAge (nAge) {cout < < _T (” created an age of “) < < < < m_nAge _T (” “) < < endl; } \
-
Person(Person& Somebody):m_nAge(Somebody. M_nAge + 10) {cout << _T(” copy creates an age of “) << _T(” Person “) << endl; } \
-
~ Person () {cout < < _T (” destructor an age of “) < < < < m_nAge _T (” “) < < endl; } \
-
\
-
public:\
-
int m_nAge; \
-
\
-
}; \
-
\
-
void Test(Person Somebody)\
-
{
\
-
return; \
-
} \
-
\
-
int _tmain(int argc, TCHAR* argv[], TCHAR* envp[])\
-
{
\
-
Person Mike(20); \
-
Test(Person(50)); \
-
return 1; \
-
}
The result of the above code is as follows:
As you can see from the result, no copy constructor is called this time, and the Person(50) temporary construct is Somebody, which is actually an object on the stack of Test, Whether this is the standard of C++ itself or the result of VS2008 helping us optimize it has not been studied yet.
\
The return value of a function is an object.
-
#include \
-
#include \
-
using namespace std; \
-
\
-
class Person\
-
{
\
-
public:\
-
Person (int nAge) : m_nAge (nAge) {cout < < _T (” created an age of “) < < < < m_nAge _T (” “) < < endl; } \
-
Person(Person& Somebody):m_nAge(Somebody. M_nAge + 10) {cout << _T(” copy creates an age of “) << _T(” Person “) << endl; } \
-
~ Person () {cout < < _T (” destructor an age of “) < < < < m_nAge _T (” “) < < endl; } \
-
\
-
public:\
-
int m_nAge; \
-
\
-
}; \
-
\
-
Person Test()\
-
{
\
-
Person Jack(30); \
-
return Jack; \
-
} \
-
\
-
int _tmain(int argc, TCHAR* argv[], TCHAR* envp[])\
-
{
\
-
Person Tom = Test(); \
-
return 1; \
-
}
The result of the above code is as follows:
A brief explanation of the above code:
The Test function is executed, Person Jack(30) is executed, and the constructor is called.
Person Tom = Test(); After the Test function is executed, the Jack object is copied to Tom, so Tom’s copy constructor is executed. After the return value assignment is complete, the Jack object’s life cycle ends and the destructor is executed. After the _tmain function returns, the Tom object’s life cycle ends and the destructor is executed.
\
-
#include \
-
#include \
-
using namespace std; \
-
\
-
class Person\
-
{
\
-
public:\
-
Person (int nAge) : m_nAge (nAge) {cout < < _T (” created an age of “) < < < < m_nAge _T (” “) < < endl; } \
-
Person(Person& Somebody):m_nAge(Somebody. M_nAge + 10) {cout << _T(” copy creates an age of “) << _T(” Person “) << endl; } \
-
~ Person () {cout < < _T (” destructor an age of “) < < < < m_nAge _T (” “) < < endl; } \
-
\
-
public:\
-
int m_nAge; \
-
\
-
}; \
-
\
-
Person Test()\
-
{
\
-
Person Jack(30); \
-
return Jack; \
-
} \
-
\
-
int _tmain(int argc, TCHAR* argv[], TCHAR* envp[])\
-
{
\
-
Test(); \
-
cout << _T(“———————–“) << endl; \
-
return 1; \
-
}
The result of the above code is as follows:
Simply analyze the above code:
We see that the code does not define an object to accept the return value of Test, but the system still creates a temporary object to accept the return value of Test, but since this temporary object is not used, it is immediately destructed.
\
-
#include \
-
#include \
-
using namespace std; \
-
\
-
class Person\
-
{
\
-
public:\
-
Person (int nAge) : m_nAge (nAge) {cout < < _T (” created an age of “) < < < < m_nAge _T (” “) < < endl; } \
-
Person(Person& Somebody):m_nAge(Somebody. M_nAge + 10) {cout << _T(” copy creates an age of “) << _T(” Person “) << endl; } \
-
~ Person () {cout < < _T (” destructor an age of “) < < < < m_nAge _T (” “) < < endl; } \
-
\
-
public:\
-
int m_nAge; \
-
\
-
}; \
-
\
-
Person Test()\
-
{
\
-
return Person (30); \
-
} \
-
\
-
int _tmain(int argc, TCHAR* argv[], TCHAR* envp[])\
-
{
\
-
Person Tom = Test(); \
-
cout << _T(“———————–“) << endl; \
-
return 1; \
-
}
The result of the above code is as follows:
As you can see from the result, there is no copy constructor called this time. The Person(30) temporarily constructed object is the Tom object. They are actually an object that exists on the stack of _tmain. It has not been studied.
\
3. The function passes in arguments and returns values as objects.
-
#include \
-
#include \
-
using namespace std; \
-
\
-
class Person\
-
{
\
-
public:\
-
Person (int nAge) : m_nAge (nAge) {cout < < _T (” created an age of “) < < < < m_nAge _T (” “) < < endl; } \
-
Person(Person& Somebody):m_nAge(Somebody. M_nAge + 10) {cout << _T(” copy creates an age of “) << _T(” Person “) << endl; } \
-
~ Person () {cout < < _T (” destructor an age of “) < < < < m_nAge _T (” “) < < endl; } \
-
\
-
public:\
-
int m_nAge; \
-
\
-
}; \
-
\
-
Person Test(Person Somebody)\
-
{
\
-
return Somebody; \
-
} \
-
\
-
int _tmain(int argc, TCHAR* argv[], TCHAR* envp[])\
-
{
\
-
Person Mike(20); \
-
Person Tom = Test(Mike); \
-
return 1; \
-
}
The result of the above code is as follows:
A simple explanation of the above code is as follows:
Person Mike(20);
The constructor is executed
\
Pass Mike as an argument to the Test function, and copy the argument to the parameter calls Somebody’s copy constructor.
\
When the Test function is finished, the Somebody object is copied to the Tom object, and the copy constructor of the Tom object is called.
\
Somebody’s life cycle ends, and the destructor executes.
The life cycle of the Tom object ends, and the destructor is executed.
The Mike object’s life cycle ends, and the destructor is executed.
Firecat instance 1 (function argument is object)
#include “stdafx.h” #include
using namespace std; class Node { public: Node() { cout << “Node1()\n”; } // Use the default copy constructor 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; } \
Running results:
Node1() 1,1,1,1 press any key to continue.. \
#include “stdafx.h” #include
using namespace std; class Node { public: Node() { cout << “Node1()\n”; } // use the custom copy constructor 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; } Run result:
Node1() Node2() 1245032,4266166,1,1 please press any key to continue.. \
Conclusion: When a class object is used as a function parameter, it is stored on the stack and does not affect the data of the argument. \
If the copy constructor is not overridden, the class’s other constructors will not be called. The data for the parameter is passed by memory copy. If overridden, the copy constructor will be called when the parameter is initialized, and no memory copy will be performed.
Firecat Instance 2 (function return value is object)
#include “stdafx.h”
#include
using namespace std; class Node { public: Node() { cout << “Node1()\n”; } // Use the default copy constructor 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; } \
Running results:
Node1() 1 Press any key to continue..
\
#include “stdafx.h”
#include
using namespace std; class Node { public: Node() { cout << “Node1()\n”; } // Use the custom copy constructor 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; }
Running results:
Node1() Node2() -858993460 Press any key to continue..
\
———————
Reference article:
Notes for C++ haters 1 — data passing of class objects as function parameters \
C++ haters note 2 – the function returns the value of class object \