C++类和对象详解（2）；初识类的默认成员函数
1.类的默认成员函数
默认成员函数就是用户没有显示实现，编译器会自动生成的成员函数称为默认成员函数。一个类我们不写的情况下编译器会默认生成以下的6个默认成员函数。
（1）构造函数：主要完成初始化的工作
（2）析构函数：主要完成销毁清理的工作
（3）拷贝构造函数：使用同类对象初始化创建对象
（4）赋值重载：主要是把一个对象赋值给另一个对象
（5）普通对象取地址重载：主要用于特殊情况，如安全敏感的应用、自定义内存管理或调试目的。在大多数日常编程中，不需要重载这个运算符。
（6）const对象取地址重载：和普通对象取地址重载一样。日常编程中不需要重载这个运算符。
以上六种默认成员函数我们主要学习前四种。
1.1构造函数
构造函数是特殊的成员函数，构造函数虽然名称是构造，但是构造函数的主要任务是实例化时初始化对象，并不是开空间创造对象（我们常使用的局部对象是栈帧创建时，空间就开好了）。
构造函数的语法特点如下
（1）函数名可以和类名相同
class MyClass {
public:MyClass() { // 构造函数与类名相同// 初始化代码}
};（2）无返回值，无返回类型。甚至不能使用void（C++规定是这样，不用纠结）
（3）对象实例化时系统会自动调用对应的构造函数
MyClass obj; // 构造函数自动调用（4）构造函数可以重载
一个类可以有多个构造函数，只要它们的参数列表不同。
class MyClass {
public:MyClass() { // 默认构造函数// 初始化代码}MyClass(int value) { // 带参数的构造函数// 使用value初始化}MyClass(int a, double b) { // 另一个重载// 使用a和b初始化}
};（5）可以有默认参数
class MyClass {
public:MyClass(int a = 0, double b = 0.0) {// 使用默认参数或提供的值初始化}
};（6）如果类中没有显式定义构造函数，则C++编译器会自动生成⼀个无参的默认构造函数，⼀旦用户显式定义编译器将不再生成。
#include<iostream>
using namespace std;
class Stack {
public:Stack()//无参的默认构造函数{}
private:int* _date;int _top;int _capacity;
};
int main()
{Stack s1;return 0;
}这里我们来调试观察s1
会发现s1会被编译器自动生成默认构造函数
1.2析构函数
析构函数与构造函数功能相反，析构函数不是完成对对象本身的销毁，比如局部对象是存在栈帧的，函数结束栈帧销毁，他就释放了，不需要我们管，C++规定对象在销毁时会自动调用析构函数，完成对象中资源的清理释放工作。
析构函数的特点如下：
（1）在类名前加~
class MyClass {
public:~MyClass() { // 析构函数// 清理代码}
};（2）无参数，无返回值也，不能被重载。一个类只能有一个析构函数 (这里跟构造类似，也不需要加void)
class MyClass {
public:~MyClass() { // 正确// 清理代码}// ~MyClass(int x) { } // 错误：析构函数不能有参数
};（3）当对象离开其作用域或被显示删除时，析构函数会自动调用。这里跟构造函数类似，我们不写编译器自动生0成的析构函数对内置类型成员不做处理，自定类型成员会调用他的析构函数。
{MyClass obj; // 对象创建// 使用对象...
} // 对象离开作用域，析构函数自动调用MyClass* ptr = new MyClass();
delete ptr; // 析构函数被调用（4）还需要注意的是我们显示写析构函数，对于自定义类型成员也会调用他的析构，也就是说自定义类型成员无论什么情况都会自动调用析构函数。
（5）对于继承层次中的对象，析构函数的调用顺序与构造函数相反：派生类的析构函数 成员对象的析构函数（按声明逆序）基类的析构函数
class Base {
public:~Base() { std::cout << "Base destructor" << std::endl; }
};class Member {
public:~Member() { std::cout << "Member destructor" << std::endl; }
};class Derived : public Base {
private:Member member;
public:~Derived() { std::cout << "Derived destructor" << std::endl; }
};// 创建Derived对象然后销毁
// 输出顺序:
// Derived destructor
// Member destructor
// Base destructor1.3拷贝构造函数
拷贝构造是一种特殊的构造函数，用于创建一个新对象来当已存在对象的副本。以下是拷贝构造的主要特点。
（1）函数名与类名相同，没有返回类型。参数必须是同类型对象的引用，通常为const引用。如果不引用可能会出现无限递归的现象。
class MyClass {
public:// 正确的拷贝构造函数MyClass(const MyClass& other) {// 复制逻辑}// 错误的拷贝构造函数示例// MyClass(MyClass other) { } // 错误：值传递会导致无限递归// MyClass(MyClass* other) { } // 错误：这不是拷贝构造函数
};如果不用引用导致递归，编译器会报错
（2）C++规定自定义类型对象进行拷贝行为必须调用拷贝构造，所以自定义类型传值传参和传值返回都会调用拷贝构造完成。
MyClass obj1;
MyClass obj2 = obj1; // 调用拷贝构造函数
MyClass obj3(obj1); // 调用拷贝构造函数void func(MyClass param); // 值传递参数时调用拷贝构造函数
func(obj1); // 调用拷贝构造函数MyClass func2() {MyClass local;return local; // 可能调用拷贝构造函数（取决于编译器优化）
}（3）若未显式定义拷贝构造，编译器会生成自动生成拷贝构造函数。自动生成的拷贝构造对内置类型成员变量会完成值拷贝/浅拷贝(⼀个字节⼀个字节的拷贝)，对自定义类型成员变量会调用他的拷贝构造。
默认拷贝构造函数的陷阱。浅拷贝构造
这对于简单类足够使用，但是遇到指针类型就会出现双重释放的问题
class ShallowCopyExample {
private:int* data;public:ShallowCopyExample(int value) {data = new int(value);}// 默认拷贝构造函数执行浅拷贝：// ShallowCopyExample(const ShallowCopyExample& other) : data(other.data) {}~ShallowCopyExample() {delete data;}
};// 使用示例
int main()
{ShallowCopyExample obj1(42);ShallowCopyExample obj2 = obj1; // 浅拷贝：两个对象的data指向同一内存return 0;
}
// 问题：obj2析构时会释放内存，然后obj1析构时再次释放同一内存 → 双重释放错误！因为浅拷贝构造的指针指向了同一块内存，我们用编译器调试或者转到反汇编就可以清楚的看到
那么我们遇到带有指针的成员变量，就需要用自定义拷贝构造来实现深拷贝。
#include <iostream>
#include <cstdlib> // 包含 malloc 和 free
#include <cstring> // 包含 strcpyclass StringWithMalloc
{
private:char* data;size_t length;public:// 构造函数 - 使用 malloc 分配内存StringWithMalloc(const char* str = ""){length = strlen(str);data = (char*)malloc(length + 1); // 使用 malloc 分配内存if (data != nullptr) {strcpy(data, str);}else {length = 0;}std::cout << "构造函数: " << (data ? data : "NULL")<< " (地址: " << (void*)data << ")" << std::endl;}// 自定义拷贝构造函数 - 使用 malloc 实现深拷贝StringWithMalloc(const StringWithMalloc& other){length = other.length;data = (char*)malloc(length + 1); // 使用 malloc 分配新内存if (data != nullptr) {strcpy(data, other.data);}else {length = 0;}std::cout << "拷贝构造函数: " << (data ? data : "NULL")<< " (新地址: " << (void*)data << ")" << std::endl;}// 析构函数 - 使用 free 释放内存~StringWithMalloc(){std::cout << "析构函数: " << (data ? data : "NULL")<< " (地址: " << (void*)data << ")" << std::endl;free(data); // 使用 free 释放内存data = nullptr; // 防止悬空指针}
};（4）传值返回会产生⼀个临时对象调用拷贝构造，传值引用返回，返回的是返回对象的别名(引用)，没有产生拷贝。但是如果返回对象是⼀个当前函数局部域的局部对象，函数结束就销毁了，那么使用引用返回是有问题的，这时的引用相当于⼀个野引用，类似⼀个野指针⼀样。传引用返回可以减少拷贝，但是⼀定要确保返回对象，在当前函数结束后还在，才能用引用返。
1.4赋值运算符重载
1.4.1运算符重载
Class Data//定义一个类
{//......
}
int main()
{Data d1;Data d2;d1-d2//这里编译器没有对应的运算符重载会报错return 0;
}（2）运算符重载是具有特殊名字的函数，他的名字是由operator和后面要定义的运算符共同构成。和其他函数⼀样，它也具有其返回类型和参数列表以及函数体。
基本语法如下
返回类型 operator操作符(参数列表) {// 函数体
}（3）重载运算符函数的参数个数和该运算符作用的运算对象数量⼀样多。⼀元运算符有⼀个参数，⼆元运算符有两个参数，⼆元运算符的左侧运算对象传给第⼀个参数，右侧运算对象传给第⼆个参数。
（4）如果⼀个重载运算符函数是成员函数，则它的第⼀个运算对象默认传给隐式的this指针，因此运算符重载作为成员函数时，参数比运算对象少⼀个。
（5）运算符重载以后，其优先级和结合性与对应的内置类型运算符保持⼀致。
（6）不能通过连接语法中没有的符号来创建新的操作符：比如operator@。
（7）.* :: sizeof ?: . 注意以上5个运算符不能重载。
（8）重载操作符至少有⼀个类类型参数，不能通过运算符重载改变内置类型对象的含义
int operator+(int x, int y)//里面没有自定义的类，都是内置类型不可重载1.4.2赋值运算符重载的特点
*this），以支持连续赋值（如 a = b = c）