C++面向对象编程：类与对象核心概念与实践

1. C++类和对象基础概念解析

在C++编程中，类和对象是最核心的概念之一，也是面向对象编程(OOP)的基石。作为一名有十年C++开发经验的工程师，我见过太多初学者因为对类和对象的理解不够深入而写出难以维护的代码。今天，我就来详细讲解C++中类和对象的基础知识，帮助大家打好面向对象编程的基础。

类是C++中用户自定义的数据类型，它封装了数据(成员变量)和操作这些数据的方法(成员函数)。而对象则是类的具体实例，就像"汽车"是一个类，"我的红色宝马"就是这个类的一个对象。理解这个关系非常重要，因为在实际开发中，我们总是先设计类，然后创建对象来使用。

提示：在C++中，类定义通常放在头文件(.h)中，而成员函数的实现放在源文件(.cpp)中，这是良好的工程实践。

1.1 类的基本结构

一个典型的C++类定义如下：

cpp复制class MyClass {
private:
    int privateVar;  // 私有成员，只能在类内部访问
    
public:
    // 构造函数
    MyClass() : privateVar(0) {}
    
    // 成员函数
    void setVar(int value) {
        privateVar = value;
    }
    
    int getVar() const {
        return privateVar;
    }
};

这个简单的例子展示了类的基本组成部分：

• 访问修饰符(private/public)
• 成员变量(privateVar)
• 构造函数(MyClass())
• 成员函数(setVar/getVar)

1.2 对象的创建与使用

创建类的对象有两种主要方式：

1. 栈上分配（自动存储期）

cpp复制MyClass obj;  // 调用默认构造函数
obj.setVar(10);

2. 堆上分配（动态存储期）

cpp复制MyClass* pObj = new MyClass();  // 使用new运算符
pObj->setVar(20);
delete pObj;  // 记得释放内存

在实际项目中，我更推荐使用智能指针(如std::unique_ptr)来管理堆上的对象，避免内存泄漏。

2. 类的三大特性详解

面向对象编程有三大基本特性：封装、继承和多态。我们先重点讨论封装，这是类和对象最核心的特性。

2.1 封装及其实现

封装是指将数据和行为捆绑在一起，并控制对内部实现的访问。在C++中，我们通过访问修饰符来实现封装：

• private：只能在类内部访问
• protected：类内部和派生类可以访问
• public：任何地方都可以访问

良好的封装实践：

cpp复制class BankAccount {
private:
    double balance;  // 私有数据成员
    
public:
    void deposit(double amount) {
        if (amount > 0) balance += amount;
    }
    
    bool withdraw(double amount) {
        if (amount > 0 && balance >= amount) {
            balance -= amount;
            return true;
        }
        return false;
    }
    
    double getBalance() const {
        return balance;
    }
};

在这个例子中，balance被设为private，外部代码不能直接修改它，必须通过deposit和withdraw方法来操作，这样就保证了数据的安全性。

2.2 构造函数与初始化

构造函数是类中非常特殊的成员函数，它在对象创建时自动调用。C++11引入了统一的初始化语法，让对象初始化更加清晰：

cpp复制class Point {
private:
    int x, y;
    
public:
    // 构造函数
    Point(int a, int b) : x(a), y(b) {}  // 成员初始化列表
    
    // C++11委托构造函数
    Point() : Point(0, 0) {}
};

使用初始化列表比在构造函数体内赋值更高效，特别是对于const成员和引用成员，必须使用初始化列表。

2.3 const成员函数

在成员函数声明后加const表示这个函数不会修改对象的状态：

cpp复制class MyArray {
private:
    int data[100];
    int size;
    
public:
    int getSize() const {  // const成员函数
        return size;
    }
    
    // 非const成员函数可以修改对象状态
    void push_back(int value) {
        if (size < 100) data[size++] = value;
    }
};

const对象只能调用const成员函数，这是C++的一个重要规则。

3. 类的特殊成员函数

除了普通成员函数外，类还有一些特殊的成员函数，它们由编译器自动生成，但我们可以自定义。

3.1 默认构造函数

如果类没有定义任何构造函数，编译器会生成一个默认构造函数。但一旦定义了任何构造函数，编译器就不会再生成默认构造函数。

cpp复制class Example {
public:
    int value;
    
    // 自定义构造函数
    Example(int v) : value(v) {}
    
    // 如果需要默认构造函数，必须显式定义
    Example() : value(0) {}
};

3.2 析构函数

析构函数在对象销毁时调用，用于释放资源。对于管理资源的类，必须定义析构函数。

cpp复制class FileHandler {
private:
    FILE* file;
    
public:
    FileHandler(const char* filename) {
        file = fopen(filename, "r");
    }
    
    ~FileHandler() {  // 析构函数
        if (file) fclose(file);
    }
};

3.3 拷贝控制成员

C++会自动生成拷贝构造函数、拷贝赋值运算符、移动构造函数和移动赋值运算符。但如果我们类管理资源，通常需要自定义这些函数。

cpp复制class String {
private:
    char* data;
    size_t length;
    
public:
    // 构造函数
    String(const char* str = "") {
        length = strlen(str);
        data = new char[length + 1];
        strcpy(data, str);
    }
    
    // 析构函数
    ~String() {
        delete[] data;
    }
    
    // 拷贝构造函数
    String(c