为什么学习面向对象编程？

面向对象编程（Object-Oriented Programming，OOP）是软件开发中的一种核心编程范式，它通过将数据和操作数据的方法（称为成员函数）包装在称为类（Class）的单一单元中，实现代码的模块化和复用。在C++中，OOP的采用使得开发者能够更有效地组织代码、提高代码的可维护性和可扩展性。OOP的核心概念包括封装、继承和多态性，它们构成了C++面向对象编程的基础。

C++面向对象编程的基本概念

在开始深入C++的面向对象编程之前，了解几个基本概念至关重要：

• 类（Class）：类是面向对象编程中的基本单位，它封装了数据（成员变量）和行为（成员函数）。
• 对象（Object）：对象是类的实例，具有特定的数据和行为。
• 封装（Encapsulation）：封装意味着数据和操作数据的方法被保留在类的内部，通过公共接口（公共成员）与外部交互。
• 继承（Inheritance）：继承允许创建一个类（子类）从另一个类（父类）继承属性和行为，促进了代码的重用。
• 多态性（Polymorphism）：多态性允许不同类的对象对同一消息做出不同的响应，通过虚函数实现。

C++面向对象基础

类与对象的定义

在C++中，定义一个类使用关键字class，成员变量和成员函数用大括号括起来。

class Rectangle {
public:
    double width;
    double height;

    // 构造函数
    Rectangle() : width(0), height(0) {}

    // 计算面积的方法
    double area() const {
        return width * height;
    }
};

创建对象并使用类的方法：

Rectangle rect;
rect.width = 10;
rect.height = 5;
std::cout << "Area: " << rect.area() << std::endl;

构造函数与析构函数的使用

构造函数在创建对象时自动调用，用于初始化对象的状态。在C++中，每个类默认有一个无参构造函数和一个拷贝构造函数。此外，还可以自定义构造函数。

class RoundedRectangle {
public:
    double width;
    double height;
    double radius;

    // 重载拷贝构造函数
    RoundedRectangle(const RoundedRectangle &other) : width(other.width), height(other.height), radius(other.radius) {}

    // 构造函数
    RoundedRectangle(double w, double h, double r) : width(w), height(h), radius(r) {}
};

成员变量与成员函数的创建

成员变量用于存储对象的数据，成员函数则定义了对象可以执行的操作。通过this关键字，成员函数可以访问到当前对象的成员变量。

封装性

数据隐藏与保护成员变量

封装的核心是隐藏数据，通过设置成员变量为私有（private）或保护（protected），限制外部直接访问，确保数据的安全。

class PrivateData {
private:
    int privateVar;

public:
    // 使用公有函数访问私有数据
    void setPrivateVar(int value) {
        privateVar = value;
    }
    int getPrivateVar() const {
        return privateVar;
    }
};

示例：通过封装保护银行账户数据

定义一个BankAccount类，包含私有成员变量，通过公有方法处理账户操作。

class BankAccount {
private:
    double balance;

public:
    BankAccount(double initBalance) : balance(initBalance) {}

    void deposit(double amount) {
        if (amount > 0) {
            balance += amount;
        }
    }

    void withdraw(double amount) {
        if (amount > 0 && amount <= balance) {
            balance -= amount;
        } else {
            std::cout << "Insufficient funds or amount must be positive" << std::endl;
        }
    }

    double getBalance() const {
        return balance;
    }
};

继承性

类的继承与派生类的创建

继承允许一个类（派生类）从另一个类（基类）继承属性和行为。在C++中，通过关键字class继承，使用:进行属性和行为的继承。

class Shape {
public:
    virtual double area() const = 0; // 虚函数，用于多态性
};

class Square : public Shape {
public:
    int side;
    Square(int s) : side(s) {}

    double area() const override {
        return side * side;
    }
};

示例：实现继承与多态性在实际应用场景中的应用

设计一个工厂类来创建不同类型的Vehicle对象，并调用它们的move()方法。

#include <iostream>
#include <memory>

class Vehicle {
public:
    virtual void move() = 0; // 虚函数
};

class Car : public Vehicle {
public:
    void move() override {
        std::cout << "Car is moving" << std::endl;
    }
};

class Bus : public Vehicle {
public:
    void move() override {
        std::cout << "Bus is moving" << std::endl;
    }
};

class VehicleFactory {
public:
    std::unique_ptr<Vehicle> createVehicle(const std::string& type) {
        if (type == "car") {
            return std::make_unique<Car>();
        } else if (type == "bus") {
            return std::make_unique<Bus>();
        }
        return nullptr;
    }
};

int main() {
    VehicleFactory factory;
    auto v = factory.createVehicle("car");
    v->move();
    
    v = factory.createVehicle("bus");
    v->move();

    return 0;
}

多态性

使用虚函数实现多态

通过使用虚函数，可以从基类对象调用派生类中重写的方法，实现动态多态性。

class Shape {
public:
    virtual ~Shape() {}

    virtual double area() const = 0;
};

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

    double area() const override {
        return width * height;
    }
};

class Square : public Rectangle {
public:
    Square(int s) : Rectangle(s, s) {}
};

void processShape(Shape *shape) {
    std::cout << "Area: " << shape->area() << std::endl;
}

int main() {
    Square sq(5);
    Rectangle rect(4, 6);

    processShape(&sq); // 调用Square的area()
    processShape(&rect); // 调用Rectangle的area()

    return 0;
}

重载与覆盖的区别

• 重载（Overloading）：同名在不同上下文中的函数，通过参数表的差异区分。
• 覆盖（Overriding）：子类中重写父类的虚函数，实现多态性。

案例实践

创建简单的类并实现面向对象设计

创建一个Vehicle类，包含基本属性和方法：

class Vehicle {
public:
    virtual void move() = 0; // 虚函数
};

class Car : public Vehicle {
public:
    void move() override {
        std::cout << "Car is moving" << std::endl;
    }
};

class Bus : public Vehicle {
public:
    void move() override {
        std::cout << "Bus is moving" << std::endl;
    }
};

实验题 1: 定义一个Calculator类，包含基本的数学运算方法（加、减、乘、除）。在main函数中创建Calculator对象并执行运算。

#include <iostream>
class Calculator {
public:
    double add(double a, double b) {
        return a + b;
    }
    double sub(double a, double b) {
        return a - b;
    }
    double mul(double a, double b) {
        return a * b;
    }
    double div(double a, double b) {
        if (b != 0) {
            return a / b;
        } else {
            std::cout << "Error: Division by zero" << std::endl;
            return 0;
        }
    }
};

int main() {
    Calculator calc;
    std::cout << "Addition: " << calc.add(5, 3) << std::endl;
    std::cout << "Subtraction: " << calc.sub(8, 2) << std::endl;
    std::cout << "Multiplication: " << calc.mul(4, 3) << std::endl;
    std::cout << "Division: " << calc.div(10, 2) << std::endl;
    std::cout << "Division by zero: " << calc.div(10, 0) << std::endl;
    return 0;
}

实验题 2: 修改BankAccount类，允许用户在存款或取款之前检查余额是否足够。

#include <iostream>
class BankAccount {
private:
    double balance;

public:
    BankAccount(double initBalance) : balance(initBalance) {}

    void deposit(double amount) {
        if (amount > 0) {
            balance += amount;
        }
    }

    void withdraw(double amount) {
        if (amount > 0 && amount <= balance) {
            balance -= amount;
        } else {
            std::cout << "Insufficient funds or amount must be positive" << std::endl;
        }
    }

    double getBalance() const {
        return balance;
    }
};

int main() {
    BankAccount account(1000);
    std::cout << "Initial balance: " << account.getBalance() << std::endl;

    account.deposit(500);
    std::cout << "After deposit: " << account.getBalance() << std::endl;

    account.withdraw(200);
    std::cout << "After withdrawal: " << account.getBalance() << std::endl;

    account.withdraw(1500); // Should not be possible
    std::cout << "After attempt to withdraw too much: " << account.getBalance() << std::endl;

    return 0;
}

进行上述实验和练习，有助于加深对C++面向对象编程概念的理解和实践应用。通过实际操作，你可以更好地掌握封装、继承和多态性的使用方法，以及如何在实践中应用面向对象的设计原则。

总结与进阶

完成本教程后，你不仅将对 C++ 面向对象编程有深入的理解，还将具备解决复杂问题的能力。这将为你的职业发展打开新的大门，无论是继续在软件开发领域深耕，还是探索其他相关技术领域，本教程都是你不可或缺的学习资源。

快来跟随本教程，探索 C++ 面向对象编程的魅力，开启你的编程之旅吧！