C++面向对象编程：从类与对象基础到实践

1. 从C到C++的跨越：理解面向对象编程的本质

第一次接触C++的类和对象时，我仿佛打开了新世界的大门。记得多年前从C语言转向C++的那个下午，当我第一次用class关键字定义出一个完整的对象时，那种"啊哈时刻"至今难忘。类和对象不是简单的语法糖，而是编程范式的根本转变。

在C语言中，我们处理的是分散的数据和函数。比如要管理一个学生信息，我们会定义结构体存储数据，再写一堆函数来操作这些数据：

c复制struct Student {
    char name[20];
    int age;
    float score;
};

void setStudentInfo(struct Student* stu, const char* name, int age, float score);
void printStudentInfo(const struct Student* stu);

这种编程方式的问题在于数据和操作是分离的，容易造成命名冲突，也难以维护。而C++的类和对象将数据和操作封装在一起，形成一个自包含的单元：

cpp复制class Student {
public:
    void setInfo(const std::string& name, int age, float score);
    void printInfo() const;
    
private:
    std::string name;
    int age;
    float score;
};

关键理解：类(class)是蓝图，对象(object)是根据这个蓝图创建的具体实例。就像建筑设计图和实际建筑物的关系。

2. 类的基本结构与成员控制

2.1 类定义的完整语法剖析

一个完整的类定义包含以下几个关键部分：

cpp复制class ClassName {
access_specifier:
    member_variables;
    member_functions();
    
access_specifier:
    // 更多成员...
};  // 注意这个分号不能少

访问控制符(access_specifier)是C++类的核心特性之一，它决定了成员的可见性：

1. public：公开成员，类外代码可以直接访问
2. private：私有成员，只有类自己的成员函数可以访问
3. protected：保护成员，与继承相关（后续文章会详细讲解）

经验法则：成员变量应该设为private，通过public成员函数来访问。这称为封装(Encapsulation)，是面向对象的重要原则。

2.2 成员函数的两种实现方式

成员函数可以在类内部直接定义，也可以在类外部定义：

方式一：类内定义（隐式inline）

cpp复制class Circle {
public:
    double getArea() { 
        return 3.14159 * radius * radius;
    }
private:
    double radius = 1.0;
};

方式二：类外定义（更常见）

cpp复制// 头文件 Circle.h
class Circle {
public:
    double getArea();
private:
    double radius = 1.0;
};

// 源文件 Circle.cpp
#include "Circle.h"

double Circle::getArea() {
    return 3.14159 * radius * radius;
}

注意类外定义时，函数名前要加ClassName::，这称为作用域解析运算符。

3. 对象的创建与使用

3.1 实例化对象的多种方式

创建对象有几种不同的语法形式：

cpp复制// 方式1：直接声明
Student stu1;  // 调用默认构造函数

// 方式2：使用括号
Student stu2();  // 注意：这实际上声明了一个函数！不是创建对象

// 方式3：使用花括号(C++11起)
Student stu3{};  // 明确表示调用构造函数

// 方式4：动态分配
Student* pStu = new Student();  // 堆上分配
// 使用后记得 delete pStu;

常见陷阱：Student stu2();这个写法看起来合理，但实际上声明了一个名为stu2的函数，它返回Student对象而不是创建对象。这是C++语法的一个著名陷阱。

3.2 访问对象成员

访问对象成员使用点运算符(.)，访问指针对象成员使用箭头运算符(->)：

cpp复制Student stu;
stu.setInfo("张三", 20, 89.5);  // 点运算符访问
stu.printInfo();

Student* pStu = new Student();
pStu->setInfo("李四", 21, 92.0);  // 箭头运算符访问
pStu->printInfo();

4. 构造函数与初始化

4.1 构造函数的基本概念

构造函数是特殊的成员函数，在创建对象时自动调用。它的名称与类名相同，没有返回类型：

cpp复制class Student {
public:
    // 构造函数
    Student(const std::string& name, int age, float score) {
        this->name = name;
        this->age = age;
        this->score = score;
    }
    
private:
    std::string name;
    int age;
    float score;
};

// 使用
Student stu("王五", 22, 85.5);

4.2 初始化列表：更高效的初始化方式

上面的构造函数虽然可行，但不是最佳实践。更好的方式是使用成员初始化列表：

cpp复制class Student {
public:
    Student(const std::string& name, int age, float score)
        : name(name), age(age), score(score) {  // 初始化列表
            // 构造函数体
    }
    
    // ...
};

初始化列表直接在成员变量创建时就初始化它们，而不是先默认初始化再赋值。对于const成员和引用成员，必须使用初始化列表。

4.3 默认构造函数

不接收任何参数的构造函数称为默认构造函数。如果没有定义任何构造函数，编译器会自动生成一个默认构造函数。但如果定义了其他构造函数，编译器就不会自动生成默认构造函数了。

cpp复制class Student {
public:
    Student() = default;  // 显式要求编译器生成默认构造函数
    
    Student(const std::string& name) : name(name) {}
    
    // ...
};

5. this指针的深入理解

每个成员函数都有一个隐藏的参数——this指针，它指向调用该函数的对象。在需要明确区分成员变量和参数时特别有用：

cpp复制class Student {
public:
    void setName(const std::string& name) {
        this->name = name;  // this->name指成员变量，name指参数
    }
    
private:
    std::string name;
};

this指针的本质是一个常量指针，意味着我们不能改变this指向的地址。在成员函数中，所有对成员的访问实际上都是通过this指针进行的。

6. 类与结构体的区别

C++中class和struct的唯一区别是默认访问权限：

• class默认成员是private的
• struct默认成员是public的

cpp复制class MyClass {
    int x;  // 默认private
};

struct MyStruct {
    int x;  // 默认public
};

现代C++中，struct通常用于只包含数据的简单结构，而class用于需要封装和更复杂行为的对象。

7. 实战案例：实现一个简单的银行账户类

让我们把这些概念应用到一个实际例子中：

cpp复制// BankAccount.h
#include <string>

class BankAccount {
public:
    BankAccount(const std::string& owner, double balance = 0.0);
    
    void deposit(double amount);
    bool withdraw(double amount);  // 返回是否成功
    double getBalance() const;
    void display() const;
    
private:
    std::string owner;
    double balance;
};

// BankAccount.cpp
#include "BankAccount.h"
#include <iostream>

BankAccount::BankAccount(const std::string& owner, double balance)
    : owner(owner), balance(balance) {}

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

bool BankAccount::withdraw(double amount) {
    if (amount > 0 && balance >= amount) {
        balance -= amount;
        return true;
    }
    return false;
}

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

void BankAccount::display() const {
    std::cout << "Account owner: " << owner 
              << ", Balance: " << balance << "\n";
}

这个简单的银行账户类展示了良好的封装实践：

• 所有数据成员都是private的
• 通过public成员函数提供受控的访问
• 包含了基本的存款、取款和查询功能

8. 常见错误与调试技巧

8.1 忘记类定义后的分号

cpp复制class MyClass {
    // ...
}  // 错误：缺少分号

8.2 混淆对象声明与函数声明

cpp复制MyClass obj();  // 这是函数声明，不是对象创建
MyClass obj{};  // 这才是创建对象

8.3 访问私有成员

cpp复制class Test {
    int secret;
};

Test t;
t.secret = 42;  // 错误：secret是private的

8.4 const成员函数的重要性

cpp复制class MyClass {
public:
    void modify() { /* 修改成员变量 */ }
    void inspect() const { /* 只读访问 */ }
};

const MyClass obj;
obj.modify();  // 错误：const对象不能调用非const成员函数
obj.inspect(); // 正确

9. 性能考量与最佳实践

1. 尽量使用初始化列表：特别是对于类类型成员，可以避免不必要的默认构造和赋值操作。

2. 小对象直接传值：对于小型类对象，直接传值可能比传引用更高效（取决于具体实现）。

3. 返回const引用：对于返回内部成员的访问函数，考虑返回const引用避免拷贝：

cpp复制class BigDataHolder {
public:
    const std::vector<int>& getData() const { return data; }
    
private:
    std::vector<int> data;
};

4. 谨慎使用inline：在类定义内实现的成员函数默认是inline的，适合小型函数，大型函数应该放在类外定义。

10. 现代C++中的类特性（前瞻）

虽然这些内容会在后续文章中详细讲解，但值得先提一下现代C++中引入的一些与类相关的重要特性：

1. 移动语义：C++11引入的移动构造函数和移动赋值运算符，可以高效转移资源所有权。

2. 委托构造函数：一个构造函数可以调用同类的另一个构造函数。

3. 默认和删除函数：= default和= delete语法。

4. constexpr构造函数：允许在编译期创建对象。

5. 结构化绑定：C++17引入的方便访问类成员的语法。

这些特性让C++中的类和对象使用更加高效和方便，我们将在后续文章中深入探讨。