深入解析C++类：面向对象编程的核心基石

一、类的本质与核心概念

1.1 类的基本定义

类是将**数据（属性）与操作（方法）**封装在一起的用户自定义类型，是面向对象编程的核心单元。

// 基础类示例
class BankAccount {
private:    // 访问控制string owner;   // 数据成员double balance;public:     // 公开接口BankAccount(const string& name, double initial = 0.0): owner(name), balance(initial) {}  // 构造函数void deposit(double amount) {   // 成员函数if (amount > 0) balance += amount;}double getBalance() const {     // const成员函数return balance;}
};

1.2 类与结构的区别

特性	class	struct
默认访问权限	private	public
继承默认权限	private	public
典型用途	复杂对象建模	数据聚合
成员函数	通常较多	通常较少

二、类的高级特性

2.1 特殊成员函数

函数类型	签名格式	自动生成条件
默认构造函数	ClassName()	无其他构造函数
析构函数	~ClassName()	总是生成
拷贝构造函数	ClassName(const ClassName&)	未显式定义移动操作
拷贝赋值运算符	ClassName& operator=(const ClassName&)	同上
移动构造函数	ClassName(ClassName&&)	未显式定义拷贝/移动操作
移动赋值运算符	ClassName& operator=(ClassName&&)	同上

// 现代C++特殊成员函数示例
class ResourceHolder {int* data;size_t size;public:// 默认构造函数ResourceHolder() : data(nullptr), size(0) {}// 参数化构造函数explicit ResourceHolder(size_t s) : data(new int[s]), size(s) {}// 移动构造函数ResourceHolder(ResourceHolder&& other) noexcept : data(other.data), size(other.size) {other.data = nullptr;other.size = 0;}// 移动赋值运算符ResourceHolder& operator=(ResourceHolder&& other) noexcept {if (this != &other) {delete[] data;data = other.data;size = other.size;other.data = nullptr;other.size = 0;}return *this;}// 析构函数~ResourceHolder() {delete[] data;}// 禁用拷贝操作ResourceHolder(const ResourceHolder&) = delete;ResourceHolder& operator=(const ResourceHolder&) = delete;
};

2.2 运算符重载

class Complex {double real, imag;public:Complex operator+(const Complex& rhs) const {return Complex(real + rhs.real, imag + rhs.imag);}// 三路比较运算符 (C++20)auto operator<=>(const Complex&) const = default;// 流输出运算符friend ostream& operator<<(ostream& os, const Complex& c) {return os << c.real << " + " << c.imag << "i";}
};

三、现代C++类特性

3.1 委托构造函数（C++11）

class Sensor {string id;double value;time_t timestamp;public:Sensor(string id) : id(move(id)), value(0), timestamp(time(nullptr)) {}Sensor(string id, double init) : Sensor(move(id)) {  // 委托基础构造函数value = init;}
};

3.2 constexpr类（C++14）

class Point {int x, y;
public:constexpr Point(int x, int y) : x(x), y(y) {}constexpr int getX() const noexcept { return x; }constexpr int getY() const noexcept { return y; }constexpr void setX(int newX) noexcept { x = newX; }constexpr void setY(int newY) noexcept { y = newY; }
};constexpr Point midpoint(const Point& p1, const Point& p2) {return { (p1.getX() + p2.getX())/2, (p1.getY() + p2.getY())/2 };
}

四、类设计模式实践

4.1 工厂模式

class Shape {
public:virtual ~Shape() = default;virtual void draw() const = 0;// 工厂方法static unique_ptr<Shape> create(const string& type) {if (type == "circle") return make_unique<Circle>();if (type == "square") return make_unique<Square>();throw invalid_argument("Unknown shape type");}
};class Circle : public Shape {
public:void draw() const override { cout << "Drawing Circle" << endl; }
};

4.2 观察者模式

class Observer {
public:virtual ~Observer() = default;virtual void update(const string& message) = 0;
};class Subject {vector<Observer*> observers;public:void attach(Observer* o) { observers.push_back(o); }void detach(Observer* o) { /* 实现分离逻辑 */ }void notify(const string& msg) {for (auto o : observers) o->update(msg);}
};

五、性能优化策略

5.1 内存布局优化

// 原始布局
class Inefficient {bool flag;    // 1字节 (实际占用4字节)int value;    // 4字节char c;       // 1字节 (总大小可能为12字节)
};// 优化布局
class Optimized {int value;    // 4字节bool flag;    // 1字节char c;       // 1字节 (总大小8字节)
};

5.2 移动语义优化

class BigData {vector<double> data;public:// 移动构造函数BigData(BigData&& other) noexcept : data(move(other.data)) {}// 移动赋值运算符BigData& operator=(BigData&& other) noexcept {data = move(other.data);return *this;}
};

六、最佳实践与常见问题

6.1 类设计原则

单一职责原则：每个类只做一件事
开放封闭原则：对扩展开放，对修改关闭
Liskov替换原则：派生类应能替换基类
依赖倒置原则：依赖抽象而非实现
组合优于继承：优先使用对象组合

6.2 常见陷阱与解决

问题1：对象切片

class Base { /*...*/ };
class Derived : public Base { /*...*/ };void process(Base b) { /*...*/ }  // 按值传递导致切片// 解决方案：使用指针或引用
void process(const Base& b) { /*...*/ }

问题2：菱形继承

class A {};
class B : public A {};
class C : public A {};
class D : public B, public C {};  // 重复继承// 解决方案：虚继承
class B : virtual public A {};
class C : virtual public A {};