C++中类与对象

在C++中，类（Class）是一种用户定义的数据类型，它封装了数据成员（变量）和成员函数（函数）。类是面向对象编程（OOP）的基础，它允许我们创建复杂的数据结构，并提供了一种方式来隐藏内部实现细节，只暴露必要的接口给外部使用。

对象（Object）是类的实例，即按照类的定义创建的具体实体。每个对象都拥有类定义的所有属性和方法，但每个对象的属性值可以独立于其他对象而存在。对象可以看作是类的具体表现，是类的蓝图在内存中的具体实现。

类的定义

类的定义通常包括访问修饰符、成员变量、成员函数和构造函数。下面是一个简单的C++类定义示例：

class Rectangle {
public:
    int width;
    int height;

    // 构造函数
    Rectangle(int w, int h) : width(w), height(h) {}

    // 成员函数
    int area() {
        return width * height;
    }
};

在这个例子中，Rectangle 是一个类，它有两个公共成员变量 width 和 height，以及一个构造函数和一个成员函数 area。构造函数用于初始化对象的状态，成员函数则提供了对对象状态的操作。

对象的创建

一旦定义了类，就可以创建该类的对象。对象的创建通常在栈上或堆上完成。

在栈上创建对象：

Rectangle rect1(10, 5); // rect1 是 Rectangle 类的一个对象

在堆上创建对象：

Rectangle* rect2 = new Rectangle(20, 10); // rect2 是指向 Rectangle 对象的指针

访问类成员

可以通过对象来访问其成员变量和调用成员函数。

int main() {
    Rectangle rect1(10, 5);
    int area = rect1.area(); // 调用 member function
    std::cout << "Area of rect1 is: " << area << std::endl;

    Rectangle* rect2 = new Rectangle(20, 10);
    int area2 = rect2->area(); // 同样调用 member function
    std::cout << "Area of rect2 is: " << area2 << std::endl;

    delete rect2; // 释放堆上的内存

    return 0;
}

在这个例子中，我们创建了两个 Rectangle 对象 rect1 和 rect2，并分别调用了它们的 area 成员函数来计算面积。

封装

封装是面向对象编程的核心原则之一，它要求将数据（成员变量）和操作这些数据的方法（成员函数）封装在一起。在C++中，可以使用访问修饰符（如 public、private 和 protected）来控制类成员的可见性和访问权限。

例如，如果我们想要将 width 和 height 成员变量设为私有，可以这样修改类定义：

class Rectangle {
private:
    int width;
    int height;

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

    int area() {
        return width * height;
    }
};

现在，width 和 height 只能通过 Rectangle 类的成员函数来访问和修改，这增加了代码的安全性和可维护性。

构造函数与析构函数

构造函数是一种特殊的成员函数，它在创建对象时自动调用，用于初始化对象。析构函数也是一种特殊的成员函数，它在对象生命周期结束时自动调用，用于执行清理工作。

构造函数示例：

class Counter {
private:
    int count;

public:
    Counter() : count(0) {} // 默认构造函数
    Counter(int initialCount) : count(initialCount) {} // 带参数的构造函数
};

析构函数示例：

class Counter {
private:
    int count;

public:
    Counter() : count(0) {}
    ~Counter() {
        // 在这里执行清理工作
    }
};

继承

C++支持类的继承，允许创建一个新的类（派生类），它继承另一个类（基类）的属性和方法。这是实现代码复用和多态性的重要机制。

继承示例：

class Square : public Rectangle {
public:
    Square(int sideLength) : Rectangle(sideLength, sideLength) {}

    void setSideLength(int length) {
        width = length;
        height = length;
    }
};

在这个例子中，Square 类继承了 Rectangle 类，并重写了 setSideLength 成员函数来设置正方形的边长。

多态

多态是指不同子类对象可以通过共同的基类接口进行操作。在C++中，多态通常通过虚函数实现。当基类指针或引用调用一个虚函数时，将执行实际对象类型的相应函数。

多态示例：

class Shape {
public:
    virtual void draw() const = 0; // 纯虚函数，定义了一个接口
    virtual ~Shape() {} // 虚析构函数
};

class Circle : public Shape {
public:
    void draw() const override {
        // 实现 Circle 的绘制逻辑
    }
};

class Rectangle : public Shape {
public:
    void draw() const override {
        // 实现 Rectangle 的绘制逻辑
    }
};

void drawShapes(const Shape& shape) {
    shape.draw(); // 多态行为，根据实际对象类型调用相应的 draw 函数
}

int main() {
    Circle circle;
    Rectangle rectangle;

    drawShapes(circle); // 输出 Circle 的绘制逻辑
    drawShapes(rectangle); // 输出 Rectangle 的绘制逻辑

    return 0;
}

在这个例子中，Shape 类有一个纯虚函数 draw，Circle 和 Rectangle 类分别实现了这个函数。drawShapes 函数接受一个 Shape 的引用，并调用其 draw 方法，由于多态，将执行实际对象类型的 draw 函数。