Summary of c++ review key points three - constructor

Constructor: The function with the same name as the class is the constructor, without a return value type declaration.

Classification of constructors: parameterless constructor, parameterized constructor, assignment (copy) constructor

Test() //无参构造函数定义
Test(inta, int b) //有参构造函数定义
Test(const Test &obj) //拷贝构造函数定义

The following three types of constructors are discussed separately

1. Constructor without parameters

Calling method: Test t1, t2; //This is easy to understand

2 Constructor with parameters

Three calling methods ：

class Test5
{ public: 
Test5(inta); 
Test5(int a, int b);
}
void main（）
{ Test5 t1(10); //c++编译器默认调用有参构造函数 括号法
Test5 t2 = (20, 10); //c++编译器默认调用有参构造函数 等号法
Test5 t3 = Test5(30); //程序员手工调用构造函数 产生了一个对象 直接调用构造构造函数法
}

3. Copy constructor

Why there is a copy constructor - to solve the copying problem of class objects

For ordinary types of objects, Copying between them is very simple, for example:

int a=88;
int b=a;

Class objects are different from ordinary objects. The internal structure of class objects is generally more complex, with various member variables. Let's look at a simple example of class object copying.

#include <iostream>
using namespace std;
class CExample {
private:
　int a;
public:
　CExample(int b)
　{ a=b;}
　void Show ()
　{
cout<<a<<endl;
}
};
int main()
{
　CExample A(100);
　CExample B=A;
　B.Show ();
　return 0;
}

Run the program and the screen outputs 100. From the running results of the above code, we can see that the system allocates memory for object B and completes the copy process with object A. As far as class objects are concerned, the entire copying process of class objects of the same type is completed through the copy constructor. The following example illustrates the working process of the copy constructor.

#include <iostream>
using namespace std;
class CExample {
private:
int a;
public:
CExample(int b)
{ a=b;}
CExample(const CExample& C)
{
a=C.a;
}
void Show ()
{
cout<<a<<endl;
}
};
int main()
{
CExample A(100);
CExample B=A;
B.Show ();
return 0;
} 
CExample(const CExample&
C)

is our custom copy constructor. It can be seen that the copy constructor is a special constructor. The name of the function must be consistent with the class name. Its only parameter is a reference variable of this type. This parameter is of const type and is immutable. For example: the form of the copy constructor of class X is X(X& x).

When an initialized custom class type object is used to initialize another newly constructed object, the copy constructor will be automatically called. In other words, when an object of the class needs to be copied, the copy constructor will be called. The copy constructor will be called in the following situations:

An object is passed into the function body by value passing

An object is returned from the function by value passing

An object needs Initialized through another object.

If a copy constructor is not explicitly declared in the class, then the compiler will automatically generate a default copy constructor, which completes bit copies between objects. Bit copy is also called shallow copy, which will be explained later.

Custom copy constructor is a good programming style, which can prevent the compiler from forming a default copy constructor and improve source code efficiency.

Shallow copy and deep copy

In some cases, member variables within a class need to dynamically allocate heap memory. If a bit copy is performed, the value in the object is completely copied to another object. Object, such as A=B. At this time, if a member variable pointer in B has allocated memory, then the member variable in A also points to the same memory. This creates a problem: when B releases the memory (such as destruction), the pointer in A becomes a wild pointer, and a runtime error occurs.

Deep copy and shallow copy can be simply understood as: if a class owns resources, when the object of this class is copied, the resources are reallocated. This process is a deep copy. On the contrary, there is no reallocation of resources. It's a shallow copy. Here is an example of deep copy.

#include <iostream>
using namespace std;
class CA
{
　public:
　　CA(int b,char* cstr)
　　{
　　　a=b;
　　　str=new char[b];
　　　strcpy(str,cstr);
　　}
　　CA(const CA& C)
　　{
　　　a=C.a;
　　　str=new char[a]; //深拷贝
　　　if(str!=0)
　　　　strcpy(str,C.str);
　　}
　　void Show()
　　{
　　　cout<<str<<endl;
　　}
　　~CA()
　　{
　　　delete str;
　　}
　private:
　　int a;
　　char *str;
};
int main()
{
　CA A(10,"Hello!");
　CA B=A;
　B.Show();
　return 0;
}

The definition of deep copy and shallow copy can be simply understood as: if a class owns resources (heap, or other system resources), when the object of this class is copied, , this process can be called a deep copy. Otherwise, if the object has resources, but the resources are not copied during the copy process, it is considered a shallow copy.

After shallow copying the resource, when the resource is released, the resource ownership will be unclear, resulting in program running errors.

Test (Test &c_t) is a custom copy constructor. The name of the copy constructor must be consistent with the class name. The formal parameter of the function is a reference variable of this type and must be a reference.

When using an already initialized custom class type object to initialize another newly constructed object, the copy constructor will be automatically called. If you do not have a custom copy constructor, The system will provide a default copy constructor to complete this process. The core copy statement of the above code is completed through the p1=c_t.p1; statement in the Test (Test &c_t) copy constructor.

The above is the third summary of the key points of C++ review - the content of the constructor. For more related content, please pay attention to the PHP Chinese website (www.php.cn)!