类和对象（中）【上篇】（构造，析构，拷贝函数）

---

  🌟个人主页：落叶

---

目录

类的默认成员函数

构造函数

无参构造

带参构造函数

全缺省构造函数

析构函数

对⽐C和C++解决括号匹配问题

C语言版的Stack

C++版的Stack

 拷⻉构造函数

---

类的默认成员函数

默认成员函数就是⽤⼾没有显式实现，编译器会⾃动⽣成的成员函数称为默认成员函数。⼀个类，我 们不写的情况下编译器会默认⽣成以下6个默认成员函数，需要注意的是这6个中最重要的是前4个，最 后两个取地址重载不重要，我们稍微了解⼀下即可。其次就是C++11以后还会增加两个默认成员函数， 移动构造和移动赋值，这个我们后⾯再讲解。默认成员函数很重要，也⽐较复杂，我们要从两个⽅⾯ 去学习：

• 第⼀：我们不写时，编译器默认⽣成的函数⾏为是什么，是否满⾜我们的需求。
• 第⼆：编译器默认⽣成的函数不满⾜我们的需求，我们需要⾃⼰实现，那么如何⾃⼰实现？

构造函数

构造函数是特殊的成员函数，需要注意的是，构造函数虽然名称叫构造，但是构造函数的主要任务并 不是开空间创建对象(我们常使⽤的局部对象是栈帧创建时，空间就开好了)，⽽是对象实例化时初始化 对象。构造函数的本质是要替代我们以前Stack和Date类中写的Init函数的功能，构造函数⾃动调⽤的 特点就完美的替代的了Init。

构造函数的特点：

1. 函数名与类名相同。

2. ⽆返回值。(返回值啥都不需要给，也不需要写void，不要纠结，C++规定如此)

3. 对象实例化时系统会⾃动调⽤对应的构造函数。

4. 构造函数可以重载。

5. 如果类中没有显式定义构造函数，则C++编译器会⾃动⽣成⼀个⽆参的默认构造函数，⼀旦⽤⼾显 式定义编译器将不再⽣成。

6. ⽆参构造函数、全缺省构造函数、我们不写构造时编译器默认⽣成的构造函数，都叫做默认构造函 数。但是这三个函数有且只有⼀个存在，不能同时存在。⽆参构造函数和全缺省构造函数虽然构成 函数重载，但是调⽤时会存在歧义。要注意很多人会认为默认构造函数是编译器默认⽣成那个叫 默认构造，实际上⽆参构造函数、全缺省构造函数也是默认构造，总结⼀下就是不传实参就可以调 ⽤的构造就叫默认构造。

6.1 默认构造有3个⽆参构造函数、全缺省构造函数，还有编译器生成的默认构造，但是这3个函数只能有一个存在， 

7. 我们不写，编译器默认⽣成的构造，对内置类型成员变量的初始化没有要求，也就是说是是否初始 化是不确定的，看编译器。对于⾃定义类型成员变量，要求调⽤这个成员变量的默认构造函数初始 化。如果这个成员变量，没有默认构造函数，那么就会报错，我们要初始化这个成员变量，需要⽤ 初始化列表才能解决，初始化列表，我们下个章节再细细讲解。

说明：C++把类型分成内置类型(基本类型)和⾃定义类型。内置类型就是语⾔提供的原⽣数据类型， 如：int/char/double/指针等，⾃定义类型就是我们使⽤class/struct等关键字⾃⼰定义的类型。

---

无参构造

add会自动调用构造函数，类中没有显式定义构造函数，编译器会⾃动⽣成⼀个⽆参的默认构造函数，⼀旦⽤⼾显 式定义编译器将不再⽣成。

#include<iostream>
using namespace std;

class date
{
public:
	//无参构造
	date()
	{
		_year = 1;
		_month = 1;
		_day = 1;
	}
	//打印
	void day()
	{
		cout << _year << "/" << _month << "/" << _day << endl;
	}

private:
	int _year;//年
	int _month;//月
	int _day;//日
};

int main()
{
	//实例化
	date add; //这里会调用默认构造（无参构造）
	add.day();
}

---

如果通过⽆参构造函数创建对象时，对象后⾯不⽤跟括号，否则编译器⽆法 区分这⾥是函数声明还是实例化对象。

// 注意：如果通过⽆参构造函数创建对象时，对象后⾯不⽤跟括号，否则编译器⽆法 
 // 区分这⾥是函数声明还是实例化对象 
 // warning C4930: “date d3(void)”: 未调⽤原型函数(是否是有意⽤变量定义的?) 
 date d3();

---

结果：

---

带参构造函数

当add有参的话，编译器会调用带参构造。

#include<iostream>
using namespace std;

class date
{
public:
	//带参构造
	date(int year,int month,int day)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	//打印
	void day()
	{
		cout << _year << "/" << _month << "/" << _day << endl;
	}

private:
	int _year;//年
	int _month;//月
	int _day;//日
};

int main()
{
	//实例化
	date add(2024,9,9);
	add.day();
}

结果：

---

全缺省构造函数

当add有参的话，也会调用全缺省构造函数。

#include<iostream>
using namespace std;

class date
{
public:
	//全缺省构造函数
	date(int year = 1, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	//打印
	void day()
	{
		cout << _year << "/" << _month << "/" << _day << endl;
	}

private:
	int _year;//年
	int _month;//月
	int _day;//日
};

int main()
{
	//实例化
	date add(2024);
	add.day();
}

---

结果：

---

编译器默认⽣成MyQueue的构造函数调⽤了Stack的构造，完成了两个成员的初始化

#include<iostream>
using namespace std;
typedef int STDataType;
class Stack
{
public:

	Stack(int n = 4)
	{
		_a = (STDataType*)malloc(sizeof(STDataType) * n);
		if (nullptr == _a)
		{
			perror("malloc申请空间失败");
			return;
		}
		_capacity = n;
		_top = 0;
	}
	// ...

private:
	STDataType* _a;
	size_t _capacity;
	size_t _top;
};
// 两个Stack实现队列 
class MyQueue
{
public:
	//编译器默认⽣成MyQueue的构造函数调⽤了Stack的构造，完成了两个成员的初始化 
private:
	Stack pushst;
	Stack popst;
};
int main()
{
	MyQueue mq;
	return 0;
}

---

结果：

---

析构函数

析构函数与构造函数功能相反，析构函数不是完成对对象本⾝的销毁，⽐如局部对象是存在栈帧的， 函数结束栈帧销毁，他就释放了，不需要我们管，C++规定对象在销毁时会⾃动调⽤析构函数，完成对 象中资源的清理释放⼯作。析构函数的功能类⽐我们之前Stack实现的Destroy功能，⽽像Date没有 Destroy，其实就是没有资源需要释放，所以严格说Date是不需要析构函数的。

析构函数的特点：

1. 析构函数名是在类名前加上字符~。

2. ⽆参数⽆返回值。(这⾥跟构造类似，也不需要加void)

3. ⼀个类只能有⼀个析构函数。若未显式定义，系统会⾃动⽣成默认的析构函数。

4. 对象⽣命周期结束时，系统会⾃动调⽤析构函数。

5. 跟构造函数类似，我们不写编译器⾃动⽣成的析构函数对内置类型成员不做处理，⾃定类型成员会 调⽤他的析构函数。

6. 还需要注意的是我们显⽰写析构函数，对于⾃定义类型成员也会调⽤他的析构，也就是说⾃定义类 型成员⽆论什么情况都会⾃动调⽤析构函数。

7. 如果类中没有申请资源时，析构函数可以不写，直接使⽤编译器⽣成的默认析构函数，如Date；如果默认⽣成的析构就可以⽤，也就不需要显⽰写析构，如MyQueue；但是有资源

申请时，⼀定要 ⾃⼰写析构，否则会造成资源泄漏，如Stack。

8.⼀个局部域的多个对象，C++规定后定义的先析构。

---

在日期类，我们可以看到一个类的⽣命周期结束时，系统会⾃动调⽤析构函数，

析构函数在生命的最后一刻可以做你想做的事，比如销毁，或把数值写到文件里。

---

我们可以看到像这个栈，需要申请空间，在类的生命周期要结束的时候，编译器调用析构函数，然后进行释放空间。

#include<iostream>
using namespace std;
typedef int STDataType;
class Stack
{
public:
	//申请空间
	Stack(int n = 4)
	{
		_a = (STDataType*)malloc(sizeof(STDataType) * n);
		if (nullptr == _a)
		{
			perror("malloc申请空间失败");
			return;
		}
		_capacity = n;
		_top = 0;
	}
	//析构函数
	~Stack()
	{
		cout << "~Stack()" << endl;
		free(_a);
		_a = nullptr;
		_top = _capacity = 0;
	}
private:
	STDataType* _a;
	size_t _capacity;
	size_t _top;
};

int main()
{
	Stack add;

	return 0;
}

结果：

---

这个Myqueue里的Stack会自动调用，Stack类里的析构函数，所以我们不用担心，Myqueue的话编译器的默认析构就够用了。

#include<iostream>
using namespace std;
typedef int STDataType;
class Stack
{
public:
	//申请空间
	Stack(int n = 4)
	{
		_a = (STDataType*)malloc(sizeof(STDataType) * n);
		if (nullptr == _a)
		{
			perror("malloc申请空间失败");
			return;
		}
		_capacity = n;
		_top = 0;
	}
	//析构函数
	~Stack()
	{
		cout << "~Stack()" << endl;
		free(_a);
		_a = nullptr;
		_top = _capacity = 0;
	}
private:
	STDataType* _a;
	size_t _capacity;
	size_t _top;
};

// 两个Stack实现队列 
class Myqueue
{
public:


private:
	// 显⽰写析构，也会⾃动调⽤Stack的析构 
 /*~MyQueue()
 {}*/
	Stack _pushst;
	Stack _popst;
};

int main()
{
	Myqueue add;

	return 0;
}

结果：

---

特殊情况：

假如_ptr指向了一块空间，那么就可以用析构函数进行释放Myqueue了。

// 两个Stack实现队列 
class Myqueue
{
public:
    //析构函数
	~Myqueue()
	{
		cout << "Myqueue" << endl;
		free(_ptr);
		_ptr = nullptr;
	 }

private:
	Stack _pushst;
	Stack _popst;
	//假如_ptr指向了一块空间，那么就可以用析构函数进行释放Myqueue了
	int* _ptr;
};

 如果类中没有申请资源时，析构函数可以不写，直接使⽤编译器⽣成的默认析构函数，如Date；如果默认⽣成的析构就可以⽤，也就不需要显⽰写析构，如MyQueue；但是有资源

申请时，⼀定要 ⾃⼰写析构，否则会造成资源泄漏，如Stack。

总结：一般情况下显示的申请空间，才需要自己实现析构函数，其他情况基本都不需要写。

---

8.⼀个局部域的多个对象，C++规定后定义的先析构。

定义的先析构，就是从下往上析构，先析构Myqueue，再到Stack，然后date。

---

对⽐C和C++解决括号匹配问题

对⽐⼀下⽤C++和C实现的Stack解决之前括号匹配问题isValid，我们发现有了构造函数和析构函数确 实⽅便了很多，不会再忘记调⽤Init和Destory函数了，也⽅便了不少。

这是OJ题目的连接:OJ题目【栈和队列】-CSDN博客

C语言版的Stack

// ⽤之前C版本Stack实现
bool isValid(const char* s) {
	ST st;
	STInit(&st);
	while (*s)
	{
		// 左括号⼊栈
		if (*s == '(' || *s == '[' || *s == '{')
		{
			STPush(&st, *s);
		}
			else // 右括号取栈顶左括号尝试匹配

			{
					if (STEmpty(&st))
					{
							STDestroy(&st);
							return false;
					}
					char top = STTop(&st);
					STPop(&st);
					// 不匹配

						if ((top == '(' && *s != ')')
								|| (top == '{' && *s != '}')
								|| (top == '[' && *s != ']'))
						{
								STDestroy(&st);
								return false;
						}
			}
		++s;
	}
	// 栈不为空，说明左括号⽐右括号多，数量不匹配
	bool ret = STEmpty(&st);
	STDestroy(&st);
	return ret;
}

---

C++版的Stack

在C++里我们就不用自己初始化了，编译器会自动调用构造函数，

在调用成员函数的时候，就不会传地址了，C++有个this隐含的指针。

C语言在每次生命周期结束前都会调用销毁函数，C++就不一样了，生命周期结束前编译器会调用析构函数，不需要我们显示写。

// ⽤最新加了构造和析构的C++版本Stack实现

bool isValid(const char* s) {
	Stack st;
	while (*s)
	{
		if (*s == '[' || *s == '(' || *s == '{')
		{
			st.Push(*s);
		}
		else
		{
			// 右括号⽐左括号多，数量匹配问题
				if (st.Empty())
				{
					return false;
				}
			// 栈⾥⾯取左括号

				char top = st.Top();
			st.Pop();
			// 顺序不匹配

				if ((*s == ']' && top != '[')
					|| (*s == '}' && top != '{')
					|| (*s == ')' && top != '('))
				{
					return false;
				}
		}
		++s;
	}
	//栈为空，返回真，说明数量都匹配左括号多，右括号少匹配问题
	return st.Empty();
}

---

 拷⻉构造函数

如果⼀个构造函数的第⼀个参数是⾃⾝类类型的引⽤，且任何额外的参数都有默认值，则此构造函数也叫做拷⻉构造函数，也就是说拷⻉构造是⼀个特殊的构造函数。

拷⻉构造的特点：

1. 拷⻉构造函数是构造函数的⼀个重载。

2. 拷⻉构造函数的第⼀个参数必须是类类型对象的引⽤，使⽤传值⽅式编译器直接报错，因为语法逻辑上会引发⽆穷递归调⽤。?拷⻉构造函数也可以多个参数，但是第⼀个参数必须是类类型对象的引⽤，后⾯的参数必须有缺省值。

3. C++规定⾃定义类型对象进⾏拷⻉⾏为必须调⽤拷⻉构造，所以这⾥⾃定义类型传值传参和传值返回都会调⽤拷⻉构造完成。

4. 若未显式定义拷⻉构造，编译器会⽣成⾃动⽣成拷⻉构造函数。⾃动⽣成的拷⻉构造对内置类型成员变量会完成值拷⻉/浅拷⻉(⼀个字节⼀个字节的拷⻉)，对⾃定义类型成员变量会调⽤他的拷⻉构造。

5. 像Date这样的类成员变量全是内置类型且没有指向什么资源，编译器⾃动⽣成的拷⻉构造就可以完成需要的拷⻉，所以不需要我们显⽰实现拷⻉构造。像Stack这样的类，虽然也都是内置类型，但是_a指向了资源，编译器⾃动⽣成的拷⻉构造完成的值拷⻉/浅拷⻉不符合我们的需求，所以需要我们⾃⼰实现深拷⻉(对指向的资源也进⾏拷⻉)。像MyQueue这样的类型内部主要是⾃定义类型Stack成员，编译器⾃动⽣成的拷⻉构造会调⽤Stack的拷⻉构造，也不需要我们显⽰实现MyQueue的拷⻉构造。这⾥还有⼀个⼩技巧，如果⼀个类显⽰实现了析构并释放资源，那么他就需要显⽰写拷⻉构造，否则就不需要。

6. 传值返回会产⽣⼀个临时对象调⽤拷⻉构造，传引⽤返回，返回的是返回对象的别名(引⽤)，没有产⽣拷⻉。但是如果返回对象是⼀个当前函数局部域的局部对象，函数结束就销毁了，那么使⽤引⽤返回是有问题的，这时的引⽤相当于⼀个野引⽤，类似⼀个野指针⼀样。传引⽤返回可以减少拷⻉，但是⼀定要确保返回对象，在当前函数结束后还在，才能⽤引⽤返回。

c++规定：类类型传值传参必须调用拷贝构造

---

我们来看这个拷贝构造，把add的数值拷贝给tab。但是为什么要用引用呢？

#include<iostream>
using namespace std;

class date
{
public:

	//全缺省构造函数
	date(int year = 1, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}

	//拷贝构造
	void go(date& d)
	{
		_year = d._year;
		_month = d._month;
		_day = d._day;
	}

private:
	int _year;//年
	int _month;//月
	int _day;//日
};

int main()
{
	date add(2024,9,10);
	//拷贝构造，把add的数拷贝初始化给tab
	date tab(add);

    //date tab = add;//当然也可以这样写
	return 0;
}

---

c++规定：类类型传值传参必须调用拷贝构造。

我们可以看到，类类型传值传参会调用拷贝构造，这样会无线的形成拷贝构造，就会无穷递归了。

所以使用引用，就不是类类型传值传参了，引用传的是d1的别名，这样就不会导致无穷递归了。

---

3. C++规定⾃定义类型对象进⾏拷⻉⾏为必须调⽤拷⻉构造，所以这⾥⾃定义类型传值传参和传值返回都会调⽤拷⻉构造完成。返回类类型，用类类型接收。

这个ret会返回临时对象，然后局部空间生命周期没了，临时对象会去调用d这个拷贝构造，这就造成权限放大了，

这里函数结束， ret对象就销毁了，也相当于了⼀个野引⽤。

权限放大：就是本来只能读的权限，调用d之后就可以修改数值，这就是权限放大。

权限缩小：就是可以读和写的权限，经过const修饰，不能写了，只能读，这就是权限缩小。

总的来说，权限放大就是多了一个或多个权限，权限缩小就是少了一个或多个权限。

Date f()
{
	Date ret;
	//...
	return ret;
}

int main()
{
	Date d5(f());
	Date d6 = f();

	return 0;
}

 用const修饰就好了。

建议：以后不需要改变d里的成员数值的话，用const修饰，不然可以会导致权限放大。

	//拷贝构造
	Date(const Date& d)
	{
		_year = d._year;
		_month = d._month;
		_day = d._day;
	}

---

 那么传指针会不会无穷递归呢，其实是不会的，

但是传指针的话就不是拷贝构造了，就只是一个普通的构造（函数）了。

#include<iostream>
using namespace std;

class date
{
public:

	//全缺省构造函数
	date(int year = 1, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}


	//不是拷贝构造，这就是个普通构造
	date(date* d)
	{
		_year = d->_year;
		_month = d->_month;
		_day = d->_day;
	}

private:
	int _year;//年
	int _month;//月
	int _day;//日
};

int main()
{
	date add(2024,9,10);
	//拷贝构造，把add的数拷贝初始化给tab
	date tab(&add);
	return 0;
}

---

4. 若未显式定义拷⻉构造，编译器会⽣成⾃动⽣成拷⻉构造函数。⾃动⽣成的拷⻉构造对内置类型成员变量会完成值拷⻉/浅拷⻉(⼀个字节⼀个字节的拷⻉)，对⾃定义类型成员变量会调⽤他的拷⻉构造。

我们可以看到不显示定义拷贝构造，编译器会自动生成拷贝构造函数，生成的就是浅拷贝，一个字节一个字节的拷贝。

---

那如果是一个栈呢。

#include<iostream>
using namespace std;
typedef int STDataType;
class Stack
{
public:
    //构造函数
    Stack(int n = 4)
    {
        _a = (STDataType*)malloc(sizeof(STDataType) * n);
        if (nullptr == _a)
        {
            perror("malloc申请空间失败");
            return;
        }
        _capacity = n;
        _top = 0;
    }
    //析构函数
    ~Stack()
    {
        cout << "~Stack" << endl;
        free(_a);
        _capacity = 0;
        _top = 0;
    }

private:
    STDataType* _a;
    size_t _capacity;
    size_t _top;
};

int main()
{
    Stack st1;
    Stack st2(st1);
	return 0;
}

---

栈用浅拷贝的话，2个对象都会指向同一块空间，

st2先析构，再到st1，st2都已经把空间释放了，就不能再释放了。

我们可以看到下面这个报错，就是释放2次同一块空间，导致的报错。

---

这种情况，就要用到深拷贝了。

#include<iostream>
using namespace std;
typedef int STDataType;
class Stack
{
public:
    //构造函数
    Stack(int n = 4)
    {
        _a = (STDataType*)malloc(sizeof(STDataType) * n);
        if (nullptr == _a)
        {
            perror("malloc申请空间失败");
            return;
        }
        _capacity = n;
        _top = 0;
    }

    //深拷贝
    Stack(const Stack& add)
    {
        //申请一块新的空间
        _a = (STDataType*)malloc(sizeof(STDataType) * add._capacity);
        if (_a == nullptr)
        {
            perror("malloc申请空间失败");
            return;
        }
        //拷贝空间里的值
        memcpy(_a, add._a, sizeof(STDataType) * add._top);

        _capacity = add._capacity;
        _top = add._top;
    }

    //析构函数
    ~Stack()
    {
        cout << "~Stack" << endl;
        free(_a);
        _capacity = 0;
        _top = 0;
    }

private:
    STDataType* _a;
    size_t _capacity;
    size_t _top;
};

int main()
{
    Stack st1(10);
    //把st1拷贝给st2
    Stack st2(st1);
	return 0;
}

---

深拷贝

给st2申请一块和st1一样的空间，然后用memcpy拷贝st1空间的值给st2。

这样析构就不会是同一块空间了。

像日期类那种没有指向空间的，使用编译器自动生成的浅拷贝就行了。 

---

总结：

第⼀：我们不写时，编译器默认⽣成的函数⾏为是什么，是否满⾜我们的需求。
第⼆：编译器默认⽣成的函数不满⾜我们的需求，我们需要⾃⼰实现，那么如何⾃⼰实现？

像这种MyQueue我们可以不用写拷贝构造，

MyQueue成员的，Stack会自动调用函数里的深拷贝，所以MyQueue用编译器生成的浅拷贝就行了。

像栈那种就要写拷贝构造了。

#include<iostream>
using namespace std;
typedef int STDataType;
class Stack
{
public:
    //构造函数
    Stack(int n = 4)
    {
        _a = (STDataType*)malloc(sizeof(STDataType) * n);
        if (nullptr == _a)
        {
            perror("malloc申请空间失败");
            return;
        }
        _capacity = n;
        _top = 0;
    }

    //深拷贝
    Stack(const Stack& add)
    {
        //申请一块新的空间
        _a = (STDataType*)malloc(sizeof(STDataType) * add._capacity);
        if (_a == nullptr)
        {
            perror("malloc申请空间失败");
            return;
        }
        //拷贝空间里的数值
        memcpy(_a, add._a, sizeof(STDataType) * add._top);

        _capacity = add._capacity;
        _top = add._top;
    }

    //析构函数
    ~Stack()
    {
        cout << "~Stack" << endl;
        free(_a);
        _capacity = 0;
        _top = 0;
    }

private:
    STDataType* _a;
    size_t _capacity;
    size_t _top;
};



class MyQueue
{
public:

private:
	Stack pushst;
	Stack popst;
};


int main()
{
    MyQueue m1;
	MyQueue m2(m1);

	return 0;
}

---

5. 像Date这样的类成员变量全是内置类型且没有指向什么资源，编译器⾃动⽣成的拷⻉构造就可以完成需要的拷⻉，所以不需要我们显⽰实现拷⻉构造。像Stack这样的类，虽然也都是内置类型，但是_a指向了资源，编译器⾃动⽣成的拷⻉构造完成的值拷⻉/浅拷⻉不符合我们的需求，所以需要我们⾃⼰实现深拷⻉(对指向的资源也进⾏拷⻉)。像MyQueue这样的类型内部主要是⾃定义类型Stack成员，编译器⾃动⽣成的拷⻉构造会调⽤Stack的拷⻉构造，也不需要我们显⽰实现MyQueue的拷⻉构造。这⾥还有⼀个⼩技巧，如果⼀个类显⽰实现了析构并释放资源，那么他就需要显⽰写拷⻉构造，否则就不需要。

6. 传值返回会产⽣⼀个临时对象调⽤拷⻉构造，传引⽤返回，返回的是返回对象的别名(引⽤)，没有产⽣拷⻉。但是如果返回对象是⼀个当前函数局部域的局部对象，函数结束就销毁了，那么使⽤引⽤返回是有问题的，这时的引⽤相当于⼀个野引⽤，类似⼀个野指针⼀样。传引⽤返回可以减少拷⻉，但是⼀定要确保返回对象，在当前函数结束后还在，才能⽤引⽤返回。

---