深入解析C++类：面向对象编程的核心基石-优快云博客

本文链接：https://blog.youkuaiyun.com/2301_76794365/article/details/146964968

一、类的本质与核心概念

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 {};