C++ 编程基础（5）类与对象 | 5.2、类

前言：

类（Class）是面向对象编程（OOP）的核心概念之一。它不仅为数据（属性）和函数（方法）提供了一个逻辑上的封装，还通过继承、多态等特性，使得代码更加模块化、可重用和易于维护。本文将深入探讨C++中的类，包括其定义、成员、构造函数与析构函数、访问控制以及在实际编程中的应用。

一、类

1、定义

在C++中，类是一种用户定义的类型，它允许我们将数据（属性）和与这些数据相关的操作（方法）封装在一起。类的定义通常使用class关键字，后面跟着类名和一对花括号，花括号内包含了类的成员声明。

class ClassName {
    // 成员变量（属性）
    // 成员函数（方法）
};

2、类成员

类的成员包括成员变量（属性）和成员函数（方法）。成员变量用于存储对象的状态，而成员函数则用于操作这些状态。

2.1、成员变量

静态成员变量是类级别的变量，它们不属于类的任何特定实例，而是被所有实例共享。以下是对C++静态成员变量相关信息的具体介绍：

静态成员变量：

• 定义与初始化：

  • 定义方式： 在类体中的数据成员声明前加上static关键字，该数据成员就成为了类的静态数据成员。例如：static int count;。
  • 初始化位置： 静态数据成员必须在类体外进行初始化，而不能在类体内初始化。初始化格式为：数据类型 类名::静态数据成员名 = 值;。例如：int MyClass::count = 0;。

• 访问与作用域：

  • 访问方式： 静态数据成员可以通过类名直接访问，也可以通过对象名访问。例如：MyClass::count或myObject.count（myObject是MyClass类的一个对象）。
  • 作用域： 静态数据成员属于类本身，而不是属于某个具体的对象。它们在程序开始运行时就已经存在，并且在整个程序运行期间都保持有效。

非静态成员变量：

C++的非静态成员变量是类的实例变量，它们属于类的每一个对象，而不是整个类。以下是对C++非静态成员变量相关信息的具体介绍：

• 定义与初始化：
  • 定义方式： 在类体中的数据成员声明前不加static关键字，该数据成员就成为了类的非静态数据成员。例如：int x;。
  • 初始化位置： 非静态数据成员可以在构造函数中初始化，也可以在创建对象时通过初始化列表进行初始化。
• 访问与作用域：
  • 访问方式： 非静态数据成员可以通过对象名或对象指针来访问。例如：object.x = 10;或objectPtr->x = 10;（假设object是类的对象，objectPtr是指向该对象的指针）。
  • 作用域： 非静态数据成员的作用域仅限于创建它们的那个对象。每个对象都有自己的非静态数据成员副本，它们之间互不影响。

2.2、成员函数

C++的成员函数可以分成两类：静态成员函数与非静态成员函数，下面是对两者间的区别的介绍，如下：

静态成员函数：

• 定义与声明：
  • 静态成员函数使用关键字 static 进行声明，并且在类外部定义时不需要指定对象实例。
  • 静态成员函数可以直接通过类名进行调用，而无需创建类的实例。
• 访问与作用域：
  • 静态成员函数可以访问类的静态成员变量和其他静态成员函数，但不能直接访问非静态成员变量或非静态成员函数。如果需要访问非静态成员，可以通过对象指针或引用作为参数传递到静态成员函数中。
  • 静态成员函数的作用域限定在它所属的类中。

注意： 通过对象名也可以直接调用静态成员函数。

非静态成员函数：

• 定义与声明：
  • 非静态成员函数是类的普通成员函数，它们不属于任何特定的对象实例，而是属于类本身。
  • 非静态成员函数可以在类定义中直接定义，也可以在类定义中声明并在类外部定义。
• 访问与作用域：
  • 非静态成员函数可以访问类的私有、保护和公有成员变量以及其他非静态成员函数。
  • 非静态成员函数的作用域限定在它所属的类中，并且它们只能通过对象实例或对象指针来调用。

总的来说，静态成员函数属于整个类，可以通过类名直接调用，主要用于实现与具体对象无关的功能；而非静态成员函数则属于类的普通成员函数，需要通过对象实例或对象指针来调用，提供了对类数据的封装和操作能力。

3、成员变量初始化顺序

成员变量的初始化顺序具备下面的特点：

• 成员变量使用初始化列表初始化时，成员变量的初始化顺序与初始化列表的顺序无关，只与定义成员变量的顺序有关。因为成员变量的初始化次序是根据变量在内存中次序进行初始化，而内存中的排列顺序早在编译期就根据变量的定义次序决定了。
• 如果不使用初始化列表初始化，在构造函数内初始化时，此时与成员变量在构造函数中的位置有关。
• 类中const成员常量必须在构造函数初始化列表中初始化。
• 类中引用类型必须在构造函数初始化列表中初始化。
• 类中static成员变量，必须在类外初始化。

4、访问控制

成员函数可以有三种访问权限：public、protected和private。

• public：可以从类的外部访问。
• protected：只能被类本身、派生类以及友元访问。
• private：只能被类本身和友元访问。

class MyClass {
public:
    void publicMethod() {
        // 公开方法
    }

protected:
    void protectedMethod() {
        // 受保护方法
    }

private:
    void privateMethod() {
        // 私有方法
    }
};

5、构造函数

5.1、定义

C++中的构造函数是一种特殊的成员函数，其主要作用是初始化对象。当创建类的新实例时，构造函数会自动被调用，以确保对象从其诞生的那一刻起就处于有效和已知的状态。构造函数具备下面的特点：

• 构造函数的名称必须与类名完全相同。
• 构造函数没有返回类型，包括void也不允许。
• 构造函数可以有参数，也可以没有参数，还可以有多个参数。
• 当创建对象时，构造函数会自动被调用。如果类中没有显式定义构造函数，编译器会为该类生成一个默认的构造函数。
• 创建一个派生类对象时，会先调用基类的构造函数，再调用派生类的构造函数。

5.2、构造函数的类型

• 默认构造函数： 没有参数的构造函数称为默认构造函数。如果类中没有定义任何构造函数，编译器会自动生成一个默认的无参构造函数。但是，如果类中定义了其他构造函数（无论是否有参数），编译器就不会再自动生成默认构造函数。
• 参数化构造函数： 接受一个或多个参数的构造函数称为参数化构造函数。它们允许在创建对象时传递参数以初始化对象的状态。
• 拷贝构造函数： 一种特殊的构造函数，用于通过另一个同类型的对象来初始化新对象。它的参数是对同类型对象的常量引用。拷贝构造函数在对象复制、作为函数参数传递对象以及从函数返回对象时都会被调用。
• 移动构造函数（C++11及以后）： 用于支持移动语义，允许在不复制资源的情况下从一个对象“移动”资源到另一个新对象。它的参数是对同类型对象的右值引用。

5.3、构造函数与类型转换

单参数构造函数（除了那些被声明为explicit的）可以参与隐式类型转换。这意味着，在需要该类类型对象的地方，如果提供了一个与构造函数参数类型匹配的值，编译器会尝试使用该值调用构造函数来创建对象。为了避免这种隐式转换，可以将单参数构造函数声明为explicit。

示例：

#include <iostream>
#include <string>

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

public:
    // 默认构造函数
    Person() : name("Unknown"), age(0) {}

    // 参数化构造函数
    Person(const std::string& name, int age) : name(name), age(age) {}

    // 拷贝构造函数
    Person(const Person& other) : name(other.name), age(other.age) {}

    // 移动构造函数（C++11及以后）
    Person(Person&& other) noexcept : name(std::move(other.name)), age(other.age) {
        other.age = 0; // 可选：将移动源对象置于有效但未定义状态
    }

    // 显示信息的方法
    void display() const {
        std::cout << "Name: " << name << ", Age: " << age << std::endl;
    }
};

int main() {
    Person p1; // 调用默认构造函数
    Person p2("Alice", 30); // 调用参数化构造函数
    Person p3 = p2; // 调用拷贝构造函数
    Person p4(std::move(p2)); // 调用移动构造函数（C++11及以后）

    p1.display();
    p2.display(); // 注意：p2在移动后可能仍然有效，但age被重置为0
    p3.display();
    p4.display();

    return 0;
}

6、析构函数

C++中的析构函数是一种特殊的成员函数，它会在对象的生命周期结束时自动调用，用于执行对象的清理工作。析构函数的主要目的是释放对象在生命周期中分配的资源，例如动态分配的内存、文件句柄、网络连接等，以防止资源泄漏。具备下面的特点：

• 析构函数的名称必须与类名完全相同，但在类名前面加上波浪号（~）。
• 析构函数不接受任何参数，也不返回任何值。
• 如果一个类没有显式定义析构函数，编译器会生成一个默认的析构函数。这个默认析构函数是一个空函数，不会执行任何操作。
• 如果一个类包含虚函数，通常建议将析构函数也声明为虚函数。这样做是为了确保当通过基类指针删除派生类对象时，能够正确调用派生类的析构函数，从而避免资源泄漏。
• 对象的析构函数按与构造函数相反的顺序调用。如果对象包含其他对象（成员对象）或基类对象，这些对象的析构函数会先被调用。

示例：

#include <iostream>

class MyClass {
public:
    MyClass() {
        std::cout << "Constructor called" << std::endl;
        // 资源分配代码（例如，动态内存分配）
    }

    ~MyClass() {
        std::cout << "Destructor called" << std::endl;
        // 资源释放代码（例如，删除动态内存）
    }
};

int main() {
    MyClass obj;
    // 构造函数在对象创建时调用
    // 当main函数结束时，obj的析构函数会被自动调用
    return 0;
}

7、this指针

在C++中，this指针是一个非常重要的概念，它指向调用成员函数的对象本身。当成员函数被调用时，编译器会自动将调用该函数的对象的地址传递给this指针。这样，成员函数内部就可以通过这个指针来访问调用它的对象的成员（包括数据成员和其他成员函数）。 this指针具备下面的特点：

• 隐式传递：当调用一个对象的成员函数时，不需要显式地将对象的地址传递给this指针。编译器会自动处理这一点。
• 类型：this指针的类型是指向类类型的指针。例如，如果有一个Person类，那么this的类型就是Person*。
• 在成员函数内部使用：在成员函数的内部，可以通过this指针来访问对象的成员。静态成员函数与非静态成员函数的一个重要区别就是静态成员函数没有this指针，因此、静态成员函数不能直接访问非静态成员。
• 返回对象自身：在运算符重载或链式调用中，成员函数常常需要返回对象自身的引用（通常是*this）。这时，this指针就非常有用。

示例代码：

#include <iostream>
#include <string>

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

public:
    // 构造函数
    Person(std::string n, int a) : name(n), age(a) {}

    // 成员函数，使用this指针
    void display() const {
        std::cout << "Name: " << this->name << ", Age: " << this->age << std::endl;
    }

    // 返回对象自身的引用
    Person& setName(const std::string& n) {
        this->name = n;
        return *this; // 返回当前对象的引用，支持链式调用
    }

    Person& setAge(int a) {
        this->age = a;
        return *this; // 同样返回当前对象的引用
    }
};

int main() {
    Person person("Alice", 30);

    // 使用this指针访问成员
    person.display();

    // 链式调用
    person.setName("Bob").setAge(25).display();

    return 0;
}

8、const 成员函数

8.1、定义

const成员函数是一种特殊类型的成员函数，它在声明时使用了const修饰符。这个修饰符表明该成员函数不会修改调用它的对象的状态，即它不会修改类的非静态成员变量。const成员函数的定义非常简单，只需在函数声明的末尾加上const关键字即可。例如：

class MyClass {
public:
    int getValue() const {
        return x;
    }
private:
    int x;
};

注意：在类外定义常成员函数时，也要加上const关键字。

8.2、const 成员函数的特点

• 不修改成员变量：const成员函数内部不能对类的非静态成员变量进行修改操作，否则会导致编译错误。
• 可读取成员变量：const成员函数可以读取类的非静态成员变量。
• 可调用其他const成员函数：const成员函数可以调用其他const成员函数，但不能调用非const成员函数。
• 与const对象一起使用：如果一个对象被声明为const，那么只有const成员函数才能被该对象调用。