C++类与对象深度解析（一）：从引用、内联函数到构造析构的编程实践

一.引用

引用的特征：1.引用必须初始化

2.本质是别名

3.函数参数传递

4.常引用

5.函数返回值

6.权限放大缩小平移

引用 vs 指针

二.内联函数

关键点说明

三.宏函数

四.类

什么是类？

简单的类

五.构造函数与析构函数

1. 构造函数（Constructor）

使用环境：

2. 析构函数（Destructor）

作用

示例

总结

六.this指针

1. 什么是 this 指针？

2. 为什么需要 this 指针？

3. 注意事项

七.拷贝构造函数

一、什么是拷贝构造函数？

二、浅拷贝（Shallow Copy）

什么是浅拷贝？

浅拷贝的问题

三、深拷贝（Deep Copy）

什么是深拷贝？

深拷贝解决方案

四、关键总结

一.引用

引用：引用不是新定义一个量而是给已存变量取一个别名，它和它引用的变量共用一块空间

引用的特征：

1.引用必须初始化

引用必须在声明时初始化，且不能重新绑定到其他对象。

int x = 10;
int &ref = x;  // 正确：引用必须初始化
// int &ref2;  // 错误：未初始化的引用

2.本质是别名

引用是变量的另一个名字，没有独立的内存地址，操作引用等价于操作原变量。

int x = 10;
int &ref = x;  // 正确：引用必须初始化
// int &ref2;  // 错误：未初始化的引用

3.函数参数传递

引用常用于函数参数，避免拷贝开销且允许修改实参（替代指针的简洁语法）。

void swap(int &x, int &y) {
    int temp = x;
    x = y;
    y = temp;
}

int main() {
    int a = 1, b = 2;
    swap(a, b);  // 直接传递变量，无需取地址
    cout << a << " " << b;  // 输出 2 1
}

4.常引用

常引用可以绑定到临时对象或字面量，且不能通过引用修改原对象。

const int &r1 = 42;  // 正确：常引用可绑定到字面量
int x = 10;
const int &r2 = x;   // 正确：r2 是 x 的只读别名
// r2 = 20;          // 错误：不能通过常引用修改值

5.函数返回值

引用可以作为函数返回值，但需确保返回的对象生命周期有效（避免悬空引用）。

int global = 100;

int& getGlobal() {
    return global;  // 返回全局变量的引用（安全）
}

int& dangerous() {
    int local = 50;
    return local;   // 错误：返回局部变量的引用（悬空引用）
}

6.权限放大缩小平移

int main()
{
	//权限不能放大
	//const int a = 0;
	//int& b = a;
	//可以只是一个拷贝
	const int c = 0;
	int d = c;
	//引用过程中权限可以平移或者缩小
	int x = 0;
	int& y = x;//权限的平移
	const int& z = x;//权限的缩小
	++x;//可以，因为上面是缩小了z的权限
	//不可以++z;

	double dd = 1.11;
	int ii = dd;
	//  不可以   int& rii = dd;
	const int& rii = dd;//临时变量具有常性
	return 0;
}

引用 vs 指针

特性	引用	指针
初始化	必须初始化	可以声明后赋值
重新绑定	不能	可以
空值	不能为空	可以为 `nullptr`
内存占用	无独立内存地址	有自己的内存地址
语法简洁性	直接操作对象（无需 `*` 或 `->`）	需要解引用操作符（`*` 或 `->`）

二.内联函数

内联函数建议编译器将函数体直接插入调用位置（类似宏展开），以减少函数调用的开销（压栈、跳转、返回等）。适用于短小且频繁调用的函数。

#include <iostream>

// 1. 使用 inline 关键字声明内联函数
inline int add(int a, int b) {
    return a + b;
}

// 2. 类内定义的成员函数默认是内联的
class Calculator {
public:
    int multiply(int a, int b) {  // 隐式内联
        return a * b;
    }

    inline int subtract(int a, int b) {  // 显式内联
        return a - b;
    }
};

int main() {
    int x = 5, y = 3;

    // 调用内联函数 add
    std::cout << "加法结果: " << add(x, y) << std::endl;  // 编译器可能直接替换为 x + y

    Calculator calc;
    // 调用类内联函数
    std::cout << "乘法结果: " << calc.multiply(x, y) << std::endl;
    std::cout << "减法结果: " << calc.subtract(x, y) << std::endl;

    return 0;
}

关键点说明

inline 关键字
用于建议编译器将函数内联，但最终是否内联由编译器决定（可通过编译器优化选项控制，如 -O2）。
类成员函数的内联性
- 在类内部直接定义的成员函数（如 multiply）默认是内联的。
- 也可以在类外定义成员函数时使用 inline 关键字（需在头文件中实现）。
适用场景
- 函数体短小（如 1-3 行代码）。
- 频繁调用且对性能敏感的场景（如循环中的操作）。
注意事项
- 避免内联复杂函数（如递归函数或包含循环的函数）。
- 内联函数定义必须对调用者可见，通常直接写在头文件中。

三.宏函数

优点-- 不需要建立栈帧，提高调用效率
缺点-- 复杂，容易出错、可读性差、不能调试

举例三个问题的宏函数

以

Add(a | b, a & b); // (a | b + a & b)

为例：
以下三个有问题：

#define Add(int x, int y) return (x+y);
#define Add(x, y) x+y
#define Add(x, y) (x+y)

原因：（+ 与- 的优先级大于| 与&）

成功示范：

#define Add(x, y) ((x)+(y))

四.类

什么是类？

类是对象的“蓝图”或“模板”，用于定义对象的属性（成员变量）和行为（成员函数）。
通过类可以创建具体的对象（实例），每个对象拥有独立的属性值。
类的核心思想是封装：将数据和对数据的操作绑定在一起，并控制外部对数据的访问权限。

简单的类

#include <iostream>
using namespace std;

// 定义一个 Person 类
class Person {
public: // 公有成员，外部可以直接访问
    char name;  // 成员变量：姓名
    int age;      // 成员变量：年龄

    // 成员函数：显示信息
    void display() {
        cout << "姓名: " << name << ", 年龄: " << age << endl;
    }
};

int main() {
    // 创建 Person 类的对象
    Person person1;

    // 设置对象的属性
    person1.name = "张三";
    person1.age = 25;

    // 调用对象的方法
    person1.display(); // 输出：姓名: 张三, 年龄: 25

    return 0;
}

封装：通过 private 隐藏内部细节，通过 public 提供安全接口

五.构造函数与析构函数

1. 构造函数（Constructor）

作用

在对象创建时自动调用，用于初始化对象的成员变量。
可以重载（定义多个不同参数的构造函数）。
没有返回类型，且名称与类名相同。

默认构造函数：无参构造函数，全缺省构造函数，编译器默认生成的构造函数

示例

构造函数：

class Person {
public:
    char name;
    int age;

    // 默认构造函数（无参数）
    Person() {
        name = "Unknown";
        age = 0;
        cout << "默认构造函数被调用" << endl;
    }

    // 带参数的构造函数
    Person(string n, int a) {
        name = n;
        age = a;
        cout << "带参数的构造函数被调用" << endl;
    }
};

使用环境：

int main() {
    Person p1;                // 调用默认构造函数
    Person p2("Alice", 25);   // 调用带参数的构造函数
    return 0;
}

2. 析构函数（Destructor）

作用

在对象销毁时自动调用，用于释放对象占用的资源（如内存、文件句柄）。
名称是类名前加 ~，没有参数和返回类型。
不能重载（每个类只有一个析构函数）。

示例

析构函数：

class FileHandler {
private:
    FILE* file;
public:
    // 构造函数：打开文件
    FileHandler(const char* filename) {
        file = fopen(filename, "r");
        cout << "文件已打开" << endl;
    }

    // 析构函数：关闭文件
    ~FileHandler() {
        if (file) {
            fclose(file);
            cout << "文件已关闭" << endl;
        }
    }
};

使用场景：

int main() {
    Person p1;                // 调用默认构造函数
    Person p2("Alice", 25);   // 调用带参数的构造函数
    return 0;
}

总结

特性	构造函数	析构函数
调用时机	对象创建时	对象销毁时
主要用途	初始化成员变量	释放资源（如内存、文件）
重载	支持重载（多个构造函数）	不支持重载（唯一析构函数）
默认生成	未定义时编译器生成默认构造函数	未定义时编译器生成默认析构函数

通过合理使用构造函数和析构函数，可以确保对象在生命周期内正确初始化和清理资源，避免内存泄漏和逻辑错误。

六.this指针

1. 什么是 `this` 指针？

在 C++ 中，this 是一个指向当前对象的指针。

每个类的非静态成员函数（包括构造函数和析构函数）内部都可以访问 this。
this 指针是隐式存在的，不需要手动定义。
它的类型是 ClassName*（例如，Person*、Car*）。

class Person {
public:
    string name;
    void printName() {
        // 实际上等价于：cout << this->name << endl;
        cout << name << endl;
    }
};

2. 为什么需要 `this` 指针？

当你在类的成员函数中访问成员变量或调用成员函数时，编译器实际上是通过 this 指针来找到当前对象的成员。
例如：

class Person {
public:
    string name;
    void printName() {
        // 实际上等价于：cout << this->name << endl;
        cout << name << endl;
    }
};