C++ 构造函数，析构函数，拷贝构造函数

1 C++类的普遍写法

新建NBAPlayer.cpp文件

#include "NBAPlayer.h"

void NBAPlayer::setAge(int age){
this->age = age;
}

int NBAPlayer::getAge(){
return this->age;
}

void NBAPlayer::setName(char *name){
this->name = name;

}
char* NBAPlayer::getName(){
return this->name;
}

新建NBAPlayer.h文件

#pragma once
class NBAPlayer{
public:
int age;
char *name;
public:
void setAge(int age);
int getAge();
void setName(char *name);
char *getName();

};

调用

#include "NBAPlayer.h"

void main(){
NBAPlayer n1;
n1.name = "WestBrook";
n1.age = 28;

cout << n1.getName() <<endl;

system("pause");
}

打印结果

WestBrook

2 构造函数

对象初始化时调用

class NBAPlayer{
private:
char *name;
int age;
public:
//无参构造函数（会覆盖默认的午餐构造函数）
NBAPlayer(){
cout << "无参构造函数" << endl;
}

//有参构造函数会覆盖默认的构造函数
NBAPlayer(char *name,int age){
this->name = name;
this->age = age;
cout << "有参构造函数"<<endl;
}

};

void main(){
NBAPlayer n;
system("pause");
}

打印结果

无参构造函数

当调用有参数构造时：

void main(){
NBAPlayer n2("Durrant",28);
system("pause");
}

打印结果

有参构造函数

另外一种调用方式

NBAPlayer n3 = NBAPlayer("Stephen Curry",29);

3 拷贝构造函数

对象销毁时调用

class NBAPlayer{
private:
char *name;
int age;
public:
NBAPlayer(){
this -> name = (char*)malloc(100);
strcpy(name,"Rose");
age = 30;
cout << "无参构造函数" << endl;
}

//析构函数
//当对象要被系统释放时，析构函数被调用
~NBAPlayer(){
cout << "析构" << endl;
//释放内存
free(this->name);
}
};

void func(){
NBAPlayer n;
}

void main(){
func();
system("pause");
}

打印结果

无参构造函数
析构

4 拷贝构造函数

class NBAPlayer{
private:
char *name;
int age;
public:
NBAPlayer(char*name,int age){
this->name = name;
this->age = age;
cout << "有参构造函数" << endl;
}

//拷贝函数
//默认拷贝构造函数，是值拷贝
NBAPlayer(const NBAPlayer &obj){
this->name=obj.name;
this->age = obj.age;
cout << "拷贝构造函数" << endl;
}

void myPrint(){
cout << name << "," << age << endl;
}
};

1 声明时赋值

void main(){
NBAPlayer n("Derric Rose",29);

//拷贝构造函数被调用的场景
//1 声明时赋值
NBAPlayer n1 = n;
n1.myPrint();
system("pause");
}

打印结果

有参构造函数
拷贝构造函数
Derric Rose,29

2 作为参数传入方法

void func(NBAPlayer n){
n.myPrint();
}

void main(){
NBAPlayer n("Derric Rose",29);

//2 作为参数传入 实参给形参赋值
func(n);

system("pause");
}

打印结果

有参构造函数
拷贝构造函数
Derric Rose,29

3 作为参数返回值返回，给变量初始化赋值

NBAPlayer func1(NBAPlayer n){
n.myPrint();
return n;
}

void main(){
NBAPlayer n("Derric Rose",29);

//3 作为参数返回值返回，给变量初始化赋值
NBAPlayer n2 = func1(n);

system("pause");
}

打印结果

有参构造函数
拷贝构造函数
Derric Rose,29

拷贝构造函数

可以看出最后一个拷贝函数执行是返回值给变量赋值时调用的。

总而言之，拷贝函数在变量初始化赋值时将会被调用。2，3中拷贝函数是在1的基础上衍生出来的。归根结底还是变量在初始化赋值时调用拷贝函数。

4 不会调用拷贝函数的情况

void main(){
NBAPlayer n("Derric Rose",29);

NBAPlayer n2("Wade",30);
//这种情况 不会调用拷贝函数
n2 = n;

system("pause");
}

5 浅拷贝

class NBAPlayer{
private:
char *name;
int age;
public:
NBAPlayer(char*name, int age){
this->name = (char*)malloc(100);
strcpy(this->name,name);
this->age = age;
cout << "有参构造函数" << endl;
}

NBAPlayer(const NBAPlayer &obj){
this->name = obj.name;
this->age = obj.age;
cout << "拷贝构造函数" << endl;
}

~NBAPlayer(){
cout << "析构函数"<< endl;

free(this->name);
}

void myPrint(){
cout << name << "," << age << endl;
}
};

void func(){
NBAPlayer n1("McGready",38);
NBAPlayer n2 = n1;
n2.myPrint();
}

void main(){
func();
system("pause");
}

运行后将会打印

有参构造函数
拷贝构造函数
McGready,38
析构函数
析构函数

然后程序会崩溃，因为在n1调用析构函数释放name后，n2在调用析构函数时，name将会为空。也就是说n1和n2操作的是同一个对象。

6 深拷贝

其他代码一样 只是在拷贝函数中把属性的值拷贝了一份

NBAPlayer(const NBAPlayer &obj){
int len = strlen(obj.name);
this->name = (char*)malloc(len+1);

//拷贝属性值
strcpy(this->name,obj.name);
this ->age = obj.age;

cout << "拷贝构造函数" << endl;
}

在此执行，运行结果一样，但是将不会报错。