C++中的类的定义和声明

背景

当我们在编写程序时，经常需要定义一些数据类型，这些数据类型可以封装数据和函数，以便我们更好地组织和管理代码。C++中的类就是一种用于定义新的数据类型的机制，它允许我们将数据和函数封装在一起，形成一个独立的模块，这个模块可以被其他代码重复使用。

类的定义和声明

类是一种用户自定义的数据类型，它可以包含数据成员和成员函数。数据成员是类的属性，成员函数是类的行为。类定义了一种新的数据类型，我们可以使用这种数据类型来创建对象，每个对象都有自己的数据成员和成员函数，在C++中，我们使用class关键字来定义一个类。类的定义包括类名、数据成员和成员函数。下面是一个简单的类定义的例子：

class Person {
public:
    // 成员函数
    void sayHello() {
        std::cout << "Hello, world!" << std::endl;
    }
private:
    // 数据成员
    std::string name;
    int age;
};

在这个例子中，我们定义了一个名为Person的类，它有一个公有成员函数sayHello和两个私有数据成员name和age。公有成员函数可以被任何代码访问，而私有数据成员只能被类的成员函数访问。

构造函数

在C++中，构造函数是一种特殊的成员函数，用于初始化对象的数据成员。构造函数的名称与类的名称相同，没有返回类型，可以有参数。当创建一个对象时，构造函数会自动调用，以初始化对象的数据成员。

class MyClass {
public:
    int publicVar;
    MyClass(int var) {
        publicVar = var;
    }
};

在上面的示例中，MyClass类有一个带有一个整数参数的构造函数，用于初始化publicVar数据成员。当创建一个MyClass对象时，可以传递一个整数参数来调用构造函数，以初始化publicVar数据成员。

❝需要注意的是，如果一个类没有定义构造函数，则编译器会自动生成一个默认构造函数。默认构造函数没有参数，不执行任何操作，只是将对象的数据成员初始化为默认值。

❞

如果一个类有多个构造函数，则可以使用函数重载来实现。函数重载是指在同一个作用域内定义多个函数，它们具有相同的名称但不同的参数列表。当调用一个重载函数时，编译器会根据传递的参数类型和数量来确定要调用哪个函数。

class MyClass {
public:
    int publicVar;
    MyClass() {
        publicVar = 0;
    }
    MyClass(int var) {
        publicVar = var;
    }
};

在上面的示例中，MyClass类有两个构造函数，一个是默认构造函数，另一个是带有一个整数参数的构造函数。当创建一个MyClass对象时，可以选择调用哪个构造函数来初始化publicVar数据成员。

析构函数

C++中的析构函数（Destructor）是一种特殊的成员函数，它在对象被销毁时自动调用。它的作用是释放对象占用的资源，比如堆上的内存、文件句柄、数据库连接等等。

C++中的析构函数使用一个波浪线（~）作为前缀，后跟类的名称。它不接受任何参数，也没有返回值，因为它的主要作用是在对象被销毁时自动执行。析构函数的名称与类名称相同，但前面有一个波浪线符号。

例如，下面是一个简单的类和它的析构函数的示例：

class MyClass {
public:
    // 构造函数
    MyClass() {
        // 构造函数代码
    }

    // 析构函数
    ~MyClass() {
        // 析构函数代码
    }
};

当程序中创建一个MyClass对象时，构造函数将被自动调用以初始化对象。当对象的生命周期结束时，析构函数将自动调用以清理对象所占用的资源。

❝需要注意的是，当一个对象被销毁时，它的析构函数会自动递归调用所有成员变量的析构函数，直到所有占用的资源都被释放为止。如果一个类中有指向堆上分配的内存的指针，需要在析构函数中手动释放这些内存，以避免内存泄漏。

❞

实例化

在C++中，要实例化一个类，你需要创建该类的对象。这可以通过声明一个类类型的变量，然后使用new关键字调用构造函数来完成。例如，如果你有一个名为MyClass的类，你可以按如下方式创建该类的对象：

MyClass* obj = new MyClass();

这将创建一个MyClass类的新对象，并返回指向该对象的指针。然后，你可以使用->运算符访问对象的公共成员。例如，如果MyClass有一个名为publicVar的公共成员，你可以按如下方式访问它：

obj->publicVar = 42;

另外，你也可以不使用new关键字创建该类的对象。例如：

MyClass obj;

这将在堆栈上创建一个MyClass类的新对象。然后，你可以使用.运算符访问对象的公共成员。例如：

obj.publicVar = 42;

访问控制

访问控制是C++中类的一个重要概念，用于控制成员的访问权限。C++中的类可以使用public、private和protected关键字来控制成员的访问权限。其中，public成员可以被任何人访问，private成员只能被类的成员函数访问，protected成员可以被类的成员函数和派生类的成员函数访问。

友元函数

在C++中，友元函数是一种特殊的函数，它可以访问一个类的私有成员和保护成员。友元函数并不是类的成员函数，因此它不能使用成员访问运算符.或->来访问类的成员。相反，它必须使用传递给它的类对象的引用来访问类的成员。

友元函数的声明需要在类的定义中进行，使用friend关键字。例如：

class MyClass {
private:
    int privateVar;
    friend void friendFunc(MyClass& obj); // 声明友元函数
};

在这个例子中，friendFunc是一个友元函数，可以访问MyClass的私有成员privateVar。注意，友元函数并不是MyClass的成员函数，因此它不能使用成员访问运算符.或->来访问MyClass的成员。相反，它必须使用传递给它的MyClass对象的引用来访问MyClass的成员。例如：

void friendFunc(MyClass& obj) {
    obj.privateVar = 42; // 可以访问私有成员
}

在这个例子中，friendFunc可以访问MyClass的私有成员privateVar，因为它被声明为MyClass的友元函数。注意，friendFunc使用传递给它的MyClass对象的引用来访问MyClass的成员。

友元函数可以是全局函数，也可以是其他类的成员函数。如果友元函数是其他类的成员函数，那么这个类必须先被定义。例如，在以下代码中，例如：

class MyClass {
private:
    int privateVar;
    friend void friendFunc(MyClass& obj); // 声明全局友元函数
    friend class FriendClass; // 声明其他类的友元类
};

void friendFunc(MyClass& obj) {
    obj.privateVar = 1; // 可以访问MyClass的私有成员
}

class FriendClass {
public:
    void friendFunc(MyClass& obj) {
        obj.privateVar = 2; // 可以访问MyClass的私有成员
    }
};

FriendClass的成员函数friendFunc被声明为MyClass的友元函数，因此它可以访问MyClass的私有成员privateVar。注意，这里的声明需要在FriendClass的定义之后进行。此外，需要注意的是，友元函数的声明只是告诉编译器这个函数是一个友元函数，它并不会影响函数的调用方式。因此，在调用友元函数时，仍然需要使用传递给它的类对象的引用来访问类的成员。例如，在以下代码中：

class MyClass {
private:
    int privateVar;
    friend void friendFunc(MyClass& obj); // 声明全局友元函数
};

void friendFunc(MyClass& obj) {
    obj.privateVar = 1; // 可以访问MyClass的私有成员
}

int main() {
    MyClass obj;
    friendFunc(obj); // 调用友元函数
    return 0;
}

虽然friendFunc是一个全局友元函数，可以访问MyClass的私有成员privateVar，但在调用friendFunc时仍然需要使用传递给它的MyClass对象的引用来访问MyClass的成员。