C++面向对象编程完全指南：从零开始理解类与对象

面向对象编程是现代软件开发的基石，而C++则是其中最强大的实现语言之一

面向对象编程（Object-Oriented Programming，简称OOP）是一种程序设计范式，它使用"对象"来模拟现实世界中的实体，是现代软件开发的基石。C++作为一门支持面向对象编程的多范式语言，其面向对象特性既强大又灵活。

1. 面向对象编程概述

1.1 什么是面向对象编程？

面向对象编程是一种以对象为中心的编程方法。它将数据和对数据的操作封装在一起，形成一个独立的实体——对象。对象之间通过消息传递进行通信。与传统的面向过程编程相比，面向对象编程更贴近人类的思维方式。在现实世界中，我们习惯于将事物看作一个个具有属性和行为的对象。例如，一只狗有颜色、品种等属性，也有叫、跑等行为。

1.2 面向对象与面向过程的对比

面向过程编程关注解决问题的步骤，将程序看作一系列线性执行的过程。而面向对象编程关注的是参与解决问题的对象，以及对象之间的交互。

下表展示了两种编程范式的主要区别：

特性	面向过程编程	面向对象编程
基本单元	函数	对象（类）
编程焦点	算法和步骤	对象和交互
数据与操作	分离	结合（封装）
重用性	函数级别重用	类级别重用
核心概念	函数、变量	类、对象、继承、多态

面向对象编程通过封装、继承和多态三大特性，提高了代码的可重用性、可扩展性和可维护性。

2. 类与对象：面向对象的基石

2.1 类（Class）：对象的蓝图

类是面向对象编程的核心概念，它是创建对象的模板或蓝图。类定义了一组对象共有的属性（数据成员）和行为（成员函数）。

在C++中，使用class关键字定义类：

class Car {
   
   
private:// 私有成员，外部不能直接访问
    string brand;
    string model;
    int year;

public:// 公有成员，外部可以访问// 构造函数
Car(string b, string m, int y) {
   
   
        brand = b;
        model = m;
        year = y;
    }

// 成员函数
void displayInfo() {
   
   
        cout << brand << " " << model << " (" << year << ")" << endl;
    }

// setter方法
void setBrand(string b) {
   
   
        brand = b;
    }

// getter方法
string getBrand() {
   
   
        return brand;
    }
};

类中的成员有三种访问权限：

• private：只能在类内部访问（默认权限）
• protected：在类内部和派生类中可访问
• public：在任何地方都可访问

2.2 对象（Object）：类的实例

对象是类的具体实例。创建对象的过程称为实例化。一个类可以创建多个对象，每个对象都有自己的属性值。

int main() {
   
   
// 创建Car类的对象
Car myCar("Toyota", "Camry", 2022);
    Car yourCar("Honda", "Accord", 2023);

// 调用对象的方法
    myCar.displayInfo();// 输出: Toyota Camry (2022)
    yourCar.displayInfo();// 输出: Honda Accord (2023)

    return 0;
}

每个对象在内存中都有独立的存储空间，保存着自己的属性值。但同一类的所有对象共享成员函数的代码。

2.3 构造函数与析构函数

构造函数

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

析构函数

在对象销毁时自动调用，用于清理资源。析构函数的名称为类名前加~符号。

class Student {
   
   
private:
    string name;
    int age;
    int* grades;// 动态数组指针

public:
// 默认构造函数
Student() : name("Unknown"), age(0), grades(nullptr) {
   
   }

// 带参数的构造函数
Student(string n, int a, int* g) : name(n), age(a) {
   
   
        grades = new int[5];
        for (int i = 0; i < 5; i++) {
   
   
            grades[i] = g[i];
        }
    }

// 析构函数
    ~Student() {
   
   
        delete[] grades;// 释放动态分配的内存
    }

// 拷贝构造函数
Student(const Student& other) : name(other.name), age(other.age) {
   
   
        grades = new int[5];
        for (int i = 0; i < 5; i++) {
   
   
            grades[i] = other.grades[i];
        }
    }
};

3. 面向对象的三大特性

3.1 封装（Encapsulation）

封装是将数据和操作数据的方法捆绑在一起的过程，同时隐藏对象的内部实现细节。封装通过访问控制符（public、private、protected）实现。封装的优点：

• 数据隐藏：保护对象内部状态不被随意修改
• 接口统一：提供统一的公共接口与对象交互
• 实现隔离：内部实现变化不影响外部代码

class BankAccount {
   
   
private:
    string accountNumber;
    double balance;

public:
    BankAccount(string accNum, double initialBalance) {
   
   
        accountNumber = accNum;
        balance = initialBalance;
    }

// 公有接口，控制对余额的访问
void