C++学习路程-6-面向对象编程（OOP）

于 2024-12-20 10:49:07 发布
阅读量1.2k 收藏 27
点赞数 36
分类专栏： 初识C++ 文章标签： c++ 学习 开发语言 笔记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_45161651/article/details/144591911
版权

1.面向对象编程（OOP）概念

1. 什么是面向对象编程？

面向对象编程（OOP）是一种编程范式，它使用“对象”作为基本构建块，将数据和操作数据的函数结合在一起。OOP通过模拟现实世界中的事物和关系，使程序设计更具模块性、可重用性和可维护性。

2. 面向对象编程（OOP）的基本概念

  • 对象：对象是类的实例，具有状态（属性）和行为（方法）。对象是OOP的基本组成部分。

  • 类：类是对象的蓝图或模板，定义了对象的属性和方法。类封装了数据和功能。

  • 封装：封装是将数据和操作数据的方法绑定在一起，并控制外部访问。通过封装，可以隐藏对象的内部状态，只暴露必要的接口。

  • 继承：继承是指一个类可以继承另一个类的属性和方法。通过继承，可以实现代码重用和扩展。

  • 多态：多态允许对象以不同的方式响应相同的消息或方法调用。多态分为编译时多态（如函数重载）和运行时多态（如虚函数）。

2. 类与对象

1.定义

1.1 类的定义

类是OOP的基本构建块，定义了对象的属性（数据成员）和行为（成员函数）。类提供了一种抽象方式，可以将现实世界中的事物建模为程序中可操作的实体。

示例：

cpp

class Car {
public:
    // 属性
    string brand;
    string model;
    int year;

    // 方法
    void displayInfo() {
        cout << "Brand: " << brand << ", Model: " << model << ", Year: " << year << endl;
    }
};

在这个例子中，Car类包含了三个属性（品牌、型号、年份）和一个方法（显示信息）。

1.2 构造函数和析构函数
  • 构造函数：构造函数是一种特殊类型的成员函数，在创建对象时自动调用，用于初始化对象的属性。构造函数的名称与类名相同，没有返回值。

示例：

cpp

class Car {
public:
    string brand;
    string model;
    int year;

    // 构造函数
    Car(string b, string m, int y) : brand(b), model(m), year(y) {}
};
  • 析构函数：析构函数也是一种特殊的成员函数，在对象生命周期结束时自动调用，用于释放资源。析构函数的名称与类名相同，但前面有一个波浪符号（~）。

示例：

cpp

class Car {
public:
    // 构造函数
    Car() {
        cout << "Car created" << endl;
    }

    // 析构函数
    ~Car() {
        cout << "Car destroyed" << endl;
    }
};
1.3 对象的创建和使用

对象是类的实例，可以通过类的构造函数创建。创建对象后，可以使用对象的属性和方法。

示例：

cpp

int main() {
    Car myCar("Toyota", "Corolla", 2020); // 创建对象
    myCar.displayInfo(); // 使用对象的方法
    return 0;
}

2. 封装

封装是OOP的核心特性之一，通过将数据和方法绑定在一起，并限制外部访问，保护对象的内部状态。

2.1 访问修饰符

访问修饰符用于控制类成员的访问权限。主要有三种修饰符：

  • public：公有成员，可以被任何其他代码访问。

  • private：私有成员，仅能在类的内部访问，外部无法访问。

  • protected：受保护成员，可以在类的内部及其派生类中访问，但外部无法直接访问。

示例：

cpp

class Car {
private:
    int speed; // 私有属性

public:
    void setSpeed(int s) { // 公有方法
        if (s >= 0) {
            speed = s;
        }
    }

    int getSpeed() const { // 公有方法
        return speed;
    }
};

在这个示例中，speed属性是私有的，外部无法直接访问，但可以通过setSpeed和getSpeed方法进行操作。

3. 继承

继承是OOP的一个重要特性，允许一个类（派生类）从另一个类（基类）继承属性和方法。通过继承，可以实现代码重用和创建类的层次结构。

3.1 基类和派生类

  • 基类：被继承的类称为基类（或父类）。

  • 派生类：从基类继承的类称为派生类（或子类）。

示例：

cpp

class Vehicle {
public:
    void start() {
        cout << "Vehicle started" << endl;
    }
};

class Car : public Vehicle { // Car类继承Vehicle类
public:
    void honk() {
        cout << "Car honks" << endl;
    }
};

在这个例子中，Car类继承了Vehicle类的start方法，并添加了自己的honk方法。

3.2 继承的访问控制

继承的访问控制决定了派生类如何访问基类的成员。使用public、protected或private关键字来控制访问权限。

  • public 继承：基类的公有成员在派生类中仍然是公有的，基类的私有成员在派生类中不可访问。

  • protected 继承：基类的公有成员在派生类中变为受保护的，基类的私有成员在派生类中不可访问。

  • private 继承：基类的公有和受保护成员在派生类中都变为私有的。

示例：

cpp

class Base {
public:
    int publicVar;
protected:
    int protectedVar;
private:
    int privateVar;
};

class Derived : public Base {
public:
    void accessMembers() {
        publicVar = 1; // 可访问
        protectedVar = 2; // 可访问
        // privateVar = 3; // 不可访问，编译错误
    }
};

4. 多态

多态是OOP的另一个重要特性，它允许不同类型的对象以相同的方式响应相同的消息。多态主要通过虚函数实现。

4.1 虚函数

虚函数是指在基类中声明，并在派生类中重写的方法。通过虚函数，可以实现运行时多态。

示例：

cpp

class Shape {
public:
    virtual void draw() { // 虚函数
        cout << "Drawing shape" << endl;
    }
};

class Circle : public Shape {
public:
    void draw() override { // 重写虚函数
        cout << "Drawing circle" << endl;
    }
};

class Square : public Shape {
public:
    void draw() override { // 重写虚函数
        cout << "Drawing square" << endl;
    }
};
4.2 纯虚函数

纯虚函数是没有实现的虚函数，通常用于定义接口。基类包含纯虚函数时，称为抽象类，不能直接实例化。

示例：

cpp

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

class Circle : public Shape {
public:
    void draw() override {
        cout << "Drawing circle" << endl;
    }
};
4.3 通过基类指针或引用调用派生类的方法

通过基类的指针或引用，可以调用派生类重写的虚函数，实现多态性。

示例：

cpp

void render(Shape* shape) {
    shape->draw(); // 根据实际对象类型调用相应的draw方法
}

int main() {
    Circle circle;
    Square square;

    render(&circle); // 输出 "Drawing circle"
    render(&square); // 输出 "Drawing square"

    return 0;
}

在这个例子中，render函数接受一个Shape类的指针，可以传入Circle或Square对象，调用相应的draw方法。

3.面向对象编程（OOP）其他方面

4. OOP的优势

  • 代码重用：通过继承和类的组合，可以重用已有的代码，减少重复工作。

  • 可维护性：OOP使得代码模块化，易于理解和修改。封装和抽象降低了复杂性。

  • 灵活性：多态提供了灵活的接口，允许对象以不同方式响应相同的消息，便于扩展功能。

  • 现实世界建模：OOP使得可以更自然地模拟现实世界中的事物和关系，增强了程序的可读性和直观性。

5. OOP的实现方式

在C++中，OOP通过类和对象的定义、使用封装、继承和多态等特性来实现。以下是基本的实现步骤：

  1. 定义类：使用class关键字定义类，包含属性和方法。

    cpp

    class ClassName {
private:
    // 属性
public:
    // 方法
};

  2. 创建对象：通过类创建对象，并访问其属性和方法。

    cpp

    ClassName obj; // 创建对象
obj.method();  // 调用方法

  3. 继承：使用:关键字实现类的继承。

    cpp

    class DerivedClass : public BaseClass {
    // 继承属性和方法
};

  4. 虚函数和多态：使用关键字virtual定义虚函数，实现运行时多态。

    cpp

    class Base {
public:
    virtual void show() {
        cout << "Base class" << endl;
    }
};

6. 常见的设计模式（简单了解）

设计模式是解决特定问题的一种通用方案，在OOP中被广泛应用。以下是一些常见的设计模式：

  • 单例模式（Singleton）：确保一个类只有一个实例，并提供全局访问点。

  • 工厂模式（Factory）：定义一个接口用于创建对象，但不明确指定具体类的实例。

  • 观察者模式（Observer）：定义一对多的依赖关系，使得当一个对象改变状态时，所有依赖于它的对象都得到通知。

  • 策略模式（Strategy）：定义一系列算法，将每个算法封装起来，并使它们可以互换。

7. OOP在C++中的应用

在C++中，OOP的应用非常广泛，以下是一些典型案例：

  • 游戏开发：通过创建角色类、物品类、场景类等，实现游戏的各种元素。

  • 图形用户界面（GUI）：使用OOP设计窗口、按钮、文本框等组件，提高界面的可维护性。

  • 大型软件系统：通过模块化设计，将复杂系统拆分为多个类，易于管理和扩展。

总结

面向对象编程（OOP）通过类与对象、封装、继承和多态等特性，提供了一种强大的程序设计方法。OOP使得代码更具可重用性、可维护性和可扩展性。在C++中，OOP的实现通过类、构造函数、析构函数、访问修饰符、虚函数等机制，极大地方便了程序的设计和开发。

评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值