C++（this指针，构造函数，析构函数，内联函数）

---

this指针

---

在C++中，this指针是一个指向当前对象的指针。它是每个非静态成员函数的一个隐式参数，并且只能在成员函数内部使用。

当一个成员函数被调用时，会自动传递当前对象的地址给this指针。通过this指针，我们可以在成员函数内部访问和操作当前对象的成员变量和其他成员函数。

this指针是一个常量指针，指向当前对象，因此不能被重新赋值。它的类型是指向类的非静态成员的指针。

使用this指针可以解决以下情况:

1. 在成员函数内部访问当前对象的成员变量和成员函数。

2. 用于区分形参和成员变量同名的情况。

3. 在一个类的成员函数内部返回当前对象本身，从而实现链式调用。

例如，考虑以下示例代码：

class MyClass {
private:
    int value;
public:
    void setValue(int value) {
        this->value = value;    // 使用this指针访问成员变量
    }
    int getValue() {
        return this->value;     // 使用this指针访问成员变量
    }
    MyClass* getThis() {
        return this;            // 返回当前对象指针
    }
};

 

---

构造函数

---

构造函数是一种特殊的成员函数，用于创建和初始化类的对象。在C++中，构造函数与类名相同，没有返回类型，且可以被重载。

构造函数在以下情况下被调用：

1. 当对象被创建时，即在定义对象时调用构造函数。例如：

   MyClass obj;             // 调用默认构造函数
   MyClass obj(10);         // 调用带参数的构造函数

     2. 在使用赋值运算符或拷贝构造函数对一个对象进行初始化时。例如： 

MyClass obj1;            // 默认构造函数
MyClass obj2 = obj1;     // 拷贝构造函数

构造函数可以有以下几种类型：

1. 默认构造函数：没有参数的构造函数被称为默认构造函数，如果没有显式定义，默认构造函数会被编译器隐式地创建。它用于在创建对象时执行默认的初始化操作。

2. 带参数的构造函数：带有参数的构造函数可以接受多个参数，并用这些参数来初始化对象的成员变量。通过带参数的构造函数，可以在创建对象时进行初始化操作。

3. 拷贝构造函数：拷贝构造函数用于将一个对象的值复制到另一个对象。它接受一个同类型的对象作为参数，通过参数对象初始化新创建的对象。

构造函数可以执行任何必要的操作来初始化对象的状态，例如分配内存、初始化成员变量、打开文件等。

构造函数的特点包括：

• 构造函数的名称与类名相同，没有返回类型。
• 构造函数可以被重载，允许多个构造函数在相同的类中存在，以便支持不同的对象初始化方式。
• 构造函数可以有默认参数，以实现更灵活的对象初始化。
• 构造函数可以在类的访问限定符 public、protected 或 private 下定义，以控制构造函数的可见性和访问权限。

例如，以下是一个使用默认构造函数和带参数构造函数的示例：

 

class Point {
private:
    int x;
    int y;
public:
    // 默认构造函数
    Point() {
        x = 0;
        y = 0;
    }

    // 带参数的构造函数
    Point(int xCoord, int yCoord) {
        x = xCoord;
        y = yCoord;
    }
};

 

 

假设我们有一个名为Person的类，用于表示人员的信息。该类有两个成员变量：name（姓名）和age（年龄）。我们可以定义不同的构造函数来初始化这些成员变量。

#include <iostream>
#include <string>

class Person {
public:
    std::string name;
    int age;

    // 默认构造函数
    Person() {
        name = "Unknown";
        age = 0;
    }

    // 带参数的构造函数
    Person(std::string personName, int personAge) {
        name = personName;
        age = personAge;
    }

    // 成员函数
    void displayInfo() {
        std::cout << "Name: " << name << std::endl;
        std::cout << "Age: " << age << std::endl;
    }
};

int main() {
    // 使用不同的构造函数创建对象并初始化
    Person person1; // 使用默认构造函数
    Person person2("Alice", 25); // 使用带参数的构造函数

    // 调用成员函数显示对象信息
    person1.displayInfo();
    person2.displayInfo();

    return 0;
}

在上面的示例中，我们定义了一个名为Person的类，并在类中定义了默认构造函数和带参数的构造函数。默认构造函数初始化成员变量为默认值，而带参数的构造函数接受参数来初始化成员变量。

在主函数中，我们使用不同的构造函数创建了两个Person对象：person1和person2。然后，我们调用了成员函数displayInfo()来显示每个对象的信息。

输出结果为：

Name: Unknown
Age: 0
Name: Alice
Age: 25

 

---

析构函数

---

析构函数（Destructor）是一个特殊的成员函数，用于在对象生命周期结束时进行清理和资源释放操作。它的名称和类名相同，但在函数名前面加上一个波浪号（~）作为标识。

析构函数的调用时机是在对象销毁时自动调用。对象销毁的情况包括：

1. 当对象在其作用域内被销毁时，例如离开了一个代码块的作用域。
2. 当一个动态分配的对象被使用delete关键字释放时。
3. 当一个对象在容器中被移除或清空时。

析构函数的主要作用是执行对象的清理操作，例如释放分配的内存、关闭打开的文件、释放占用的资源等。在析构函数中可以进行任何需要进行清理和释放的操作。

注意以下几点有关析构函数的规则：

• 类中只能有一个析构函数，不能被重载。它不接受任何参数，包括无返回值。
• 如果在类中没有显式定义析构函数，编译器会生成一个默认的析构函数。
• 析构函数在类的访问限定符 public、protected 或 private 下定义，但通常是定义为 public。

以下是一个示例演示了析构函数的使用：

class MyClass {
private:
    int* data;
public:
    // 构造函数
    MyClass() {
        data = new int[10];
    }

    // 析构函数
    ~MyClass() {
        delete[] data;
    }
};

当一个对象销毁时，它的析构函数会被自动调用，可以在析构函数中执行清理和释放资源的操作。

举一个简单的例子，假设有一个File类用于表示一个文件，并在析构函数中关闭文件句柄。示例代码如下：

#include <iostream>
#include <fstream>

class File {
private:
    std::ofstream file;

public:
    // 构造函数，打开文件
    File(const std::string& filename) {
        file.open(filename);
        if (!file.is_open()) {
            throw std::runtime_error("Failed to open file.");
        }
    }

    // 析构函数，关闭文件
    ~File() {
        if (file.is_open()) {
            file.close();
        }
    }

    // 写入数据到文件
    void write(const std::string& data) {
        if (file.is_open()) {
            file << data;
        }
    }
};

int main() {
    // 创建一个File对象
    File myfile("example.txt");

    // 向文件中写入数据
    myfile.write("Hello, World!");

    // 当main函数结束时，myfile对象会被销毁
    // 此时会自动调用析构函数，关闭文件句柄

    return 0;
}

在上面的例子中，当main函数结束时，myfile对象会被销毁，此时会自动调用析构函数。析构函数会检查文件是否处于打开状态，如果是，则关闭文件句柄，确保资源正确释放。

这个例子演示了析构函数的作用，可以在其中进行清理和资源释放操作，以确保对象销毁时的安全性和正确性。

 

 

---

内联函数

---

内联函数（Inline Functions）是C++中一种函数的特性，用于在编译器进行函数调用时，将函数的定义插入到调用位置处，以避免函数调用的开销。内联函数的关键字是inline。

内联函数的主要目的是提高程序的执行效率，特别是对于一些简短、频繁调用的函数。通常，函数的调用会引入一定的开销，包括参数传递、栈帧创建、返回值传递等。而内联函数的机制可以避免这些开销，直接将函数的定义插入到调用的地方，从而减少了函数调用的开销，提高了程序的执行效率。

以下是使用内联函数的一些规则和特性：

需要注意的是，内联函数并不是一定会被编译器内联扩展的，它只是一种建议。编译器会根据一些因素（例如函数的复杂性、函数的调用频率等）来决定是否实际进行内联扩展。

使用内联函数可以提高程序的执行效率，但需要注意合理的使用场景和注意内联函数的复杂性，在性能和代码可维护性之间进行权衡。

1. 内联函数的定义通常放在头文件中，以便在需要使用函数的地方进行内联扩展。

2. 函数声明的同时使用关键字inline可以将函数标记为内联函数。例如：

   inline int max(int a, int b) {
       return (a > b) ? a : b;
   }

3. 内联函数的定义体通常需要放在函数声明之前，以便编译器能够在需要内联函数的地方进行内联扩展。

4. 内联函数的定义体应该尽可能简单，避免包含复杂的控制结构和大量的代码，因为复杂的函数体会导致内联扩展的代码增加，反而降低执行效率。

5. 内联函数一般适用于函数体较短的函数，一般以几行到十几行为宜。对于复杂的函数逻辑或循环结构，不适合使用内联函数。