构造函数和析构函数-CSDN博客

c++中的类可以定义与类名相同的特殊成员函数，这种那个与类名相同的成员函数叫做构造函数，

构造函数分为有参数和无参数的，没有任何返回值类型的声明。

构造函数的调用分为

自动调用：一般情况下c++编译器会自动调用构造函数

手动调用：在一些情况下则需要手动调用构造函数

拷贝构造函数：当类中没有定义拷贝构造函数时，所有类都有一个默认的拷贝构造函数，拷贝构造函数只是做简单的赋值

调用时机：

1、Test t2 = t1;   // 用对象 t1 去初始化t2
2、Test t2(t0);    // 用对象 t0 去初始化t2
3、PrintObj(t0);   // 做函数参数的时候
4、t1 = test();       // 函数返回值返回对象

拷贝构造是确确实实构造一个新的对象，并给新对象的私有成员赋上参数对象的私有成员的值，新构造的对象和参数对象地址是不一样的，所以如果该类中有一个私有成员是指向堆中某一块内存，如果仅仅对该私有成员进行浅拷贝，那么会出现多个指针指向堆中同一块内存，这是会出现问题，如果那块内存被释放了，就会出现其他指针指向一块被释放的内存，出现未定义的值的问题，如果深拷贝，就不会出现问题，因为深拷贝，不会出现指向堆中同一块内存的问题，因为每一次拷贝，都会开辟新的内存供对象存放其值。

#include <iostream>
#include <string.h>
using namespace std;

class A
{
private:
    int* n;

public:
    A()
    {
        n = new int[10];
        n[0] = 1;
        cout<<"constructor is called\n";
    }

    /*A(const A& a)
    {
        n = a.n; //delete两次同一块内存会出错 
        cout<<"copy constructor is called\n";
    }*/
    
    A(const A& a)
    {
        n = new int[10];
        memcpy(n, a.n, 10);  //通过按字节拷贝，将堆中一块内存存储到另一块内存
        cout<<"copy constructor is called\n";
    }

    ~A()
    {
        cout<<"destructor is called\n";
        delete n;
    }

    void get()
    {
        cout<<"n[0]: "<<n[0]<<endl;
    }
};


int main()
{
    A* a = new A();
    A b = *a;
    delete a;

    b.get();

    return 0;
}

new和delete：

在C语言中是利用库函数malloc和free来分配和撤销内存空间的。C++提供了较简便而功能较强的运算符new和delete来取代malloc和free函数。new和delete是运算符，不是函数，因此执行效率高。

几个例子：

#include<iostream>
using namespace std;
int main()
{
	int *p1=(int *)malloc(sizeof(int));
	*p1=1;
	free(p1);
	
	int *p2=(int *)malloc(sizeof(int)*10);
	for(int i=0;i<10;i++)
	{
		*(p2+i)=i;
	}
	free(p2);
	
	int *p3=new int;
	cout<<*p3<<endl;
	delete p3;
	
	int *p4=new int [10];
	for(int i=0;i<10;i++)
	{
		cout<<p4[i]<<endl;
	}
	delete p4;
};

1）当类中没有定义任何一个构造函数时，c++编译器会提供默认无参构造函数和默认拷贝构造函数
2）当类中定义了拷贝构造函数时，c++编译器不会提供无参数构造函数
3）当类中定义了任意的非拷贝构造函数（即：当类中提供了有参构造函数或无参构造函数），c++编译器不会提供默认无参构造函数
4 ）默认拷贝构造函数成员变量简单赋值

注意的是，只要你写了构造函数，那么你必须要用

构造函数可以有多个，但是析构函数只有一个，

1）C++中的类可以定义一个特殊的成员函数清理对象，这个特殊的成员函数叫做析构函数
语法：

class A
{
public:
    A()
    {
        std::cout << "我是构造函数，被调用了" << std::endl;

    }
    ~A()
    {
        std::cout << "我是析构函数，被调用了" << std::endl;
    }
};

2）析构函数没有参数也没有任何返回类型的声明
3）析构函数在对象销毁时自动被调用