类

C++ 中的类提供了一种以面向对象的方式结构化组织代码的方法。面向对象编程 (OOP) 是一种围绕对象的概念，封装其数据和行为的编程范式。类用作创建对象的蓝图或模板。

方法

方法是与类相关联的函数。有时它被称为成员函数，因为它操作类的成员（数据）。

#include <iostream>

// 类的声明
class Rectangle {
public:
    // 成员变量（数据成员）
    double length;
    double width;

    // 成员函数（方法）
    double calculateArea() {
        return length * width;
    }
};

int main() {
    // 创建类的实例（对象）
    Rectangle myRectangle;
    myRectangle.length = 5.0;
    myRectangle.width = 3.0;

    // 访问成员函数执行计算
    double area = myRectangle.calculateArea();

    std::cout << "Rectangle Area: " << area << std::endl;

    return 0;
}

构造函数和析构函数

构造函数和析构函数是 C++ 类中的特殊成员函数，分别用于初始化和清理资源。构造函数在对象创建时调用，而析构函数在对象超出作用域或显式删除时调用。

#include <iostream>

class Rectangle {
public:
    // 构造函数（默认构造函数）
    Rectangle() {
        std::cout << "Default Constructor called" << std::endl;
        length = 0.0;
        width = 0.0;
    }

    // 参数化构造函数
    Rectangle(double len, double wid) {
        std::cout << "Parameterized Constructor called" << std::endl;
        length = len;
        width = wid;
    }

    void setDimensions(double len, double wid) {
        length = len;
        width = wid;
    }

    double calculateArea() {
        return length * width;
    }

    // 析构函数
    ~Rectangle() {
        std::cout << "Destructor called" << std::endl;
    }

private:
    // 成员变量
    double length;
    double width;
};

int main() {
    // 使用默认构造函数创建类的实例
    Rectangle defaultRectangle;

    // 使用参数化构造函数创建类的实例
    Rectangle customRectangle(5.0, 3.0);

    customRectangle.setDimensions(8.0, 4.0);

    double areaDefault = defaultRectangle.calculateArea();
    double areaCustom = customRectangle.calculateArea();

    std::cout << "Area of Default Rectangle: " << areaDefault << std::endl;
    std::cout << "Area of Custom Rectangle: " << areaCustom << std::endl;

    // 当 customRectangle 超出作用域时，将调用析构函数
    return 0;
}

封装

封装是面向对象编程（OOP）的基本原则之一，也是 C++ 的关键特性之一。它是指将数据（属性）和在数据上操作的方法（函数）捆绑到一个称为类的单元中。 通过提供公共（public）、私有（private）和受保护（protected）的访问指示符来控制对数据的访问。

在前面的代码示例中，length 和 width 是 Rectangle 类的私有（private）成员变量。它们是内部封装的数据，只能在类内部访问。

继承

继承是面向对象编程的基本概念之一，允许新类（称为派生类或子类）从现有类（称为基类或父类）继承属性和行为。在 C++ 中，可以使用 class 关键字和 :（冒号）符号实现继承。

#include <iostream>

// 基类（父类）
class Shape {
protected:
    double width;
    double height;

public:
    Shape(double w, double h) : width(w), height(h) {}

    // 用于计算面积的虚函数
    virtual double calculateArea() const {
        return width * height;
    }
};

// 派生类（子类）
class Rectangle : public Shape {
public:
    // 为 Rectangle 初始化基类的构造函数
    Rectangle(double w, double h) : Shape(w, h) {}

    // 覆盖 calculateArea 方法
    double calculateArea() const override {
        return width * height;
    }
};

int main() {
    // 创建派生类的对象
    Rectangle myRectangle(5.0, 3.0);

    // 使用覆盖的 calculateArea 方法
    double areaRectangle = myRectangle.calculateArea();

    // 显示结果
    std::cout << "Area of Rectangle: " << areaRectangle << std::endl;

    return 0;
}

多态

多态是面向对象编程的一个关键概念，允许将不同类型的对象视为公共的基本类型的对象。然后在实际使用时，再呈现其各自多样的形态。

#include <iostream>

class Shape {
public:
    virtual double calculateArea() const {
        return 0.0; // 基类的默认实现
    }
};

class Rectangle : public Shape {
private:
    double width;
    double height;

public:
    Rectangle(double w, double h) : width(w), height(h) {}

    // 覆盖 calculateArea 方法
    double calculateArea() const override {
        return width * height;
    }
};

class Triangle : public Shape {
private:
    double base;
    double height;

public:
    Triangle(double b, double h) : base(b), height(h) {}

    // 覆盖 calculateArea 方法
    double calculateArea() const override {
        return 0.5 * base * height;
    }
};

// 使用多态的函数，计算并显示任何形状的面积
void displayArea(const Shape& shape) {
    double area = shape.calculateArea();
    std::cout << "Area: " << area << std::endl;
}

int main() {
    Rectangle myRectangle(5.0, 3.0);
    Triangle myTriangle(4.0, 6.0);

    displayArea(myRectangle);
    displayArea(myTriangle);

    return 0;
}

虚函数

虚函数使多态成为可能，允许派生类提供其自己的实现逻辑，而不是基类中的函数逻辑。

virtual double calculateArea() const {
    return 0.0; // 基类的默认实现
}

如前面的代码示例中所示，calculateArea 是基类中的虚函数。

纯虚函数

在 C++ 中，纯虚函数是在基类中声明的没有实现的虚拟函数，它应该由派生类来实现。包含一个或多个纯虚函数的类被称为抽象类，它不能用于创建实例。

// 抽象基类（父类）具有一个纯虚函数
class Shape {
public:
    // 用于计算面积的纯虚函数
    virtual double calculateArea() const = 0;

    // 非虚函数
    void displayShapeInfo() const {
        std::cout << "This is a shape." << std::endl;
    }
};

友元函数

友元函数是一个不是类的成员但可以访问类的私有和受保护成员的函数。友元函数在类内用 friend 关键字声明。

#include <iostream>

// 类的前向声明（方便下面用到的地方知道此类存在）
class Rectangle;

// 友元函数前向声明
void displayDimensions(const Rectangle& rect);

class Rectangle {
private:
    double length;
    double width;

public:
    Rectangle(double len, double wid) : length(len), width(wid) {}

    // 友元函数在类内声明
    friend void displayDimensions(const Rectangle& rect);
};

// 友元函数定义
void displayDimensions(const Rectangle& rect) {
    // 访问 Rectangle 类的私有成员
    std::cout << "Length: " << rect.length << ", Width: " << rect.width << std::endl;
}

int main() {
    Rectangle myRectangle(5.0, 3.0);

    // 调用友元函数
    displayDimensions(myRectangle);

    return 0;
}

代码挑战

创建一个简单的程序来管理图书库存。定义两个类，Book 和 InventoryManager。