类

在 C++ 中，**类（Class）和对象（Object）**是面向对象编程的核心概念。类是对象的蓝图，定义了对象的属性和行为，而对象是类的实例，拥有类所定义的属性和功能。以下是对 C++ 中类和对象的详细解释。

1. 类的基本概念

类是用户定义的类型，包含数据成员（属性）和成员函数（方法）。数据成员用于存储对象的状态，成员函数定义了对象的行为。通过定义类，程序员可以创建自己的数据类型，像使用内置类型一样使用这些自定义类型。

类的基本语法

class ClassName {
public:
    // 构造函数
    ClassName();
    
    // 成员函数（方法）
    void someMethod();
    
    // 数据成员（属性）
    int someAttribute;

private:
    // 私有数据成员和方法
    int privateAttribute;
};

• class 关键字用于定义类。

• public 和 private 是访问控制修饰符，控制类成员的可见性。

  • public：在类外部可以访问的成员。

  • private：只能在类内部访问的成员，默认情况下，类的成员都是私有的。

2. 对象的基本概念

对象是类的实例化，表示具体的实体。一个类可以创建多个对象，每个对象都有自己的一组数据成员值。对象通过使用类中的成员函数来执行操作。

对象的创建和使用

ClassName obj;  // 创建对象 obj
obj.someMethod();  // 调用对象的方法
obj.someAttribute = 10;  // 访问对象的属性

3. 类的成员

3.1 数据成员（属性）

数据成员用于定义类的状态，可以是基本数据类型或其他对象。

class Car {
public:
    string brand;  // 公有数据成员
    int year;
};

3.2 成员函数（方法）

成员函数是类中定义的函数，用来操作类的数据成员。

class Car {
public:
    string brand;
    int year;

    // 成员函数
    void displayInfo() {
        cout << "Brand: " << brand << ", Year: " << year << endl;
    }
};

3.3 构造函数

构造函数是一个特殊的成员函数，在对象创建时自动调用，用于初始化对象的状态。构造函数的名字与类名相同，没有返回类型。

class Car {
public:
    string brand;
    int year;

    // 构造函数
    Car(string b, int y) {
        brand = b;
        year = y;
    }

    void displayInfo() {
        cout << "Brand: " << brand << ", Year: " << year << endl;
    }
};

使用构造函数创建对象：

Car myCar("Toyota", 2021);
myCar.displayInfo();

3.4 析构函数

析构函数是另一个特殊的成员函数，在对象销毁时自动调用，用于释放资源。析构函数的名字是类名前加 ~，没有参数，也没有返回值。

class Car {
public:
    Car() {
        cout << "Car object created" << endl;
    }

    ~Car() {
        cout << "Car object destroyed" << endl;
    }
};

3.5 静态成员

静态成员属于类本身，而不是某个特定的对象。静态成员在所有对象之间共享。

• 静态数据成员：需要在类外部进行初始化。

  class Car {
  public:
      static int carCount;  // 静态成员
  };
  
  int Car::carCount = 0;  // 类外初始化静态成员

• 静态成员函数：只能访问静态成员。

  class Car {
  public:
      static int carCount;
  
      static void showCarCount() {
          cout << "Car count: " << carCount << endl;
      }
  };

4. 访问控制

C++ 提供了三种访问控制修饰符：public、private 和 protected，用于控制类成员的可见性。

• public：类外部和类内部都可以访问。

• private：只能在类的内部访问，类外部无法直接访问。

• protected：与 private 类似，但子类可以访问。

class Car {
private:
    string brand;
public:
    void setBrand(string b) {
        brand = b;
    }

    string getBrand() {
        return brand;
    }
};

在上述示例中，brand 是私有的，不能直接从类外访问，只能通过 setBrand 和 getBrand 这样的公有函数访问。

5. 继承

继承允许一个类从另一个类继承数据成员和成员函数。被继承的类称为基类，继承的类称为派生类。

class Vehicle {
public:
    int speed;
    void setSpeed(int s) {
        speed = s;
    }
};

// 派生类 Car 继承自基类 Vehicle
class Car : public Vehicle {
public:
    string brand;
    void setBrand(string b) {
        brand = b;
    }
};

通过继承，派生类 Car 继承了 Vehicle 类的成员函数 setSpeed 和数据成员 speed。

6. 多态

C++ 中的多态性可以通过虚函数来实现，允许在父类中定义的函数在子类中重新定义。

class Animal {
public:
    virtual void sound() {
        cout << "Some generic animal sound" << endl;
    }
};

class Dog : public Animal {
public:
    void sound() override {  // 重写父类的 sound 函数
        cout << "Woof!" << endl;
    }
};

使用多态调用函数时，可以通过基类的指针或引用来调用派生类的重写版本：

Animal* myAnimal = new Dog();
myAnimal->sound();  // 输出: Woof!

7. 封装

封装是将类的实现细节隐藏起来，只暴露必要的接口给外部，用户通过接口操作对象，而不需要知道内部实现。这通过使用访问控制修饰符来实现，如 private 和 public。

class BankAccount {
private:
    double balance;  // 私有数据成员

public:
    // 通过公有成员函数操作私有数据
    void deposit(double amount) {
        balance += amount;
    }

    double getBalance() {
        return balance;
    }
};

8. 抽象

抽象是一种表示通用行为的方式，通常使用抽象类来实现。抽象类包含纯虚函数，这些函数在基类中没有实现，派生类需要提供实现。

class Shape {
public:
    virtual void draw() = 0;  // 纯虚函数
};

class Circle : public Shape {
public:
    void draw() override {
        cout << "Drawing a circle" << endl;
    }
};

Shape 类是一个抽象类，不能实例化，只能通过派生类来实现。

总结

• 类是对象的模板或蓝图，定义了数据和行为。

• 对象是类的实例，具有类的所有属性和方法。

• 通过类和对象，C++ 提供了实现面向对象编程的核心机制，包括封装、继承、多态和抽象。