1. C++封装与类的本质
在C++的世界里，类（class）是面向对象编程的核心概念之一。与C语言那种数据和函数分离的方式不同，C++通过类将数据（成员变量）和操作这些数据的函数（成员函数）封装在一起，形成一个完整的逻辑单元。这种封装特性带来了更好的代码组织性、安全性和可维护性。
1.1 类的定义与结构
一个典型的类定义如下所示：
cpp复制class Stack {
private:
void Init(int capacity = 4) {
_array = (int*)malloc(sizeof(int)*capacity);
assert(_array);
_capacity = capacity;
_top = 0;
}
public:
int* _array;
size_t _capacity;
size_t _top;
};
这里有几个关键点需要注意：
class是定义类的关键字，Stack是类名- 大括号
{}内是类的主体，包含成员变量和成员函数 - 成员变量通常以下划线开头命名（如
_array），这是一种常见的命名约定 - 成员函数可以直接在类内定义，默认会被视为内联函数
1.2 访问权限控制
C++通过访问限定符来实现封装性，主要有三种：
- public：公有成员，可以在类外直接访问
- private：私有成员，只能在类内部访问
- protected：保护成员，与继承相关，后续会讨论
cpp复制class Stack {
public:
void Push(int x); // 公有方法，外部可调用
private:
int* _array; // 私有成员，只能在类内部访问
};
重要提示：良好的封装实践通常会将成员变量设为private，只通过public方法提供访问接口。这样可以控制对内部数据的访问，防止外部代码随意修改内部状态。
2. this指针的奥秘
2.1 this指针的作用
在C++中，每个成员函数都隐含一个名为this的指针参数，它指向调用该成员函数的对象实例。通过this指针，成员函数可以访问当前对象的成员变量和其他成员函数。
cpp复制class Data {
public:
void SetYear(int year) {
this->_year = year; // 使用this指针访问成员变量
}
private:
int _year;
};
2.2 this指针的实际应用
this指针在以下几种情况下特别有用：
- 解决命名冲突：当参数名与成员变量名相同时
cpp复制void SetYear(int _year) {
this->_year = _year; // 使用this区分成员变量和参数
}
- 链式调用：返回*this可以实现方法链
cpp复制class Data {
public:
Data& SetYear(int year) {
_year = year;
return *this;
}
Data& SetMonth(int month) {
_month = month;
return *this;
}
};
// 使用方式
Data d;
d.SetYear(2023).SetMonth(5); // 链式调用
- 在成员函数中返回当前对象：
cpp复制class Counter {
public:
Counter& increment() {
count++;
return *this;
}
private:
int count = 0;
};
3. 类与结构体的区别
3.1 默认访问权限
在C++中，class和struct的主要区别在于默认访问权限：
class：默认成员是privatestruct：默认成员是public
cpp复制class MyClass {
int x; // 默认private
};
struct MyStruct {
int x; // 默认public
};
3.2 使用场景
- 使用
class：当需要强调封装性，隐藏实现细节时 - 使用
struct：当数据成员需要直接访问，或者需要与C兼容时
实际开发中，很多团队会约定：仅当需要与C兼容或作为纯数据载体时才使用struct，其他情况一律使用class。
4. 内联函数详解
4.1 内联函数的概念
内联函数是C++提供的一种优化手段，通过在调用点展开函数体来避免函数调用的开销。它特别适合短小且频繁调用的函数。
cpp复制inline int max(int x, int y) {
return x > y ? x : y;
}
4.2 内联函数的特性
- 减少函数调用开销：省去了参数压栈、跳转、返回等操作
- 可能增加代码体积：函数体会被复制到每个调用点
- 编译器决定权：inline只是建议，编译器可能拒绝内联复杂函数
4.3 类中的内联函数
在类定义内部直接实现的成员函数默认是内联的：
cpp复制class Calculator {
public:
int add(int a, int b) { // 默认内联
return a + b;
}
};
4.4 内联函数与宏的区别
| 特性 | 内联函数 | 宏 |
|---|---|---|
| 类型检查 | 有 | 无 |
| 调试支持 | 可以调试 | 预处理后消失 |
| 副作用 | 参数只求值一次 | 可能多次求值 |
| 作用域 | 遵循作用域规则 | 全局替换 |
5. 类的实例化与对象模型
5.1 实例化过程
类本身不占用内存空间，只有实例化为对象后才会分配内存：
cpp复制class Data {
int _year;
int _month;
int _day;
};
int main() {
Data d1; // 实例化对象d1
Data d2; // 实例化对象d2
}
5.2 对象的内存布局
- 对象只存储成员变量，不存储成员函数
- 成员函数被所有对象共享，通过this指针区分不同对象
- 对象大小由成员变量决定，考虑内存对齐
cpp复制class Empty {}; // sizeof(Empty) == 1 (空类最小大小为1)
class Data {
int _year; // 4字节
char _month; // 1字节
// 通常会有3字节填充，使总大小为8（取决于对齐规则）
};
5.3 类与对象的关系
- 类是蓝图，对象是实例
- 一个类可以实例化多个对象
- 每个对象有独立的数据成员，共享成员函数
6. 封装的最佳实践
6.1 良好的封装习惯
- 数据隐藏：成员变量设为private，通过方法访问
- 提供完备的接口：考虑各种使用场景
- 保持接口稳定：修改内部实现不影响外部调用
- 合理使用const：标记不修改对象状态的方法
cpp复制class BankAccount {
public:
double getBalance() const { // const成员函数
return _balance;
}
void deposit(double amount) {
if (amount > 0) _balance += amount;
}
private:
double _balance = 0;
};
6.2 封装带来的好处
- 安全性：防止外部代码随意修改内部状态
- 可维护性：内部实现可以自由修改而不影响使用者
- 易用性：提供清晰的接口，隐藏复杂实现
- 可测试性：通过接口可以更方便地进行单元测试
7. 常见问题与解决方案
7.1 头文件中的类定义
在头文件中定义类时需要注意：
- 成员函数实现可以放在类内（隐式内联）
- 或者声明在类内，实现在类外（需要inline关键字）
cpp复制// Stack.h
class Stack {
public:
void push(int x); // 声明
private:
int* _array;
};
inline void Stack::push(int x) { // 实现
// ...
}
7.2 循环依赖问题
当两个类互相引用时会产生循环依赖，解决方案：
- 使用前向声明
- 将实现分离到.cpp文件
- 考虑重新设计类关系
cpp复制// 前向声明
class B;
class A {
B* b_ptr;
};
class B {
A* a_ptr;
};
7.3 const对象与成员函数
const对象只能调用const成员函数：
cpp复制class Data {
public:
void print() const { // const成员函数
cout << _year;
}
void setYear(int y) { // 非const成员函数
_year = y;
}
private:
int _year;
};
const Data d;
d.print(); // OK
d.setYear(2023); // 错误！不能调用非const方法
8. 高级话题：友元与静态成员
8.1 友元函数与友元类
友元打破了封装性，允许特定函数或类访问私有成员：
cpp复制class Secret {
friend class Spy; // Spy可以访问Secret的私有成员
friend void peek(const Secret&); // peek函数可以访问
private:
int _code;
};
class Spy {
public:
void expose(const Secret& s) {
cout << s._code; // 可以访问私有成员
}
};
注意：友元应该谨慎使用，它会削弱封装性。
8.2 静态成员
静态成员属于类本身，而不是类的对象：
- 静态成员变量：所有对象共享同一份数据
- 静态成员函数：没有this指针，只能访问静态成员
cpp复制class Counter {
public:
static int count; // 声明
Counter() { count++; }
static int getCount() { return count; }
};
int Counter::count = 0; // 定义并初始化
int main() {
Counter c1, c2;
cout << Counter::getCount(); // 输出2
}
静态成员常用于：
- 维护类级别的状态
- 实现单例模式
- 提供工具函数
9. 实战经验分享
在实际项目中，合理使用类和封装可以显著提高代码质量。以下是一些经验之谈：
- 命名规范：保持一致的命名风格，如成员变量加前缀或后缀
- 单一职责：一个类只做一件事，避免"上帝类"
- 深浅拷贝：注意拷贝构造函数和赋值运算符的实现
- RAII原则：利用构造函数和析构函数管理资源
- 移动语义：现代C++中合理实现移动构造函数和移动赋值
cpp复制class Buffer {
public:
Buffer(size_t size) : _size(size), _data(new int[size]) {}
~Buffer() { delete[] _data; } // RAII
// 禁用拷贝
Buffer(const Buffer&) = delete;
Buffer& operator=(const Buffer&) = delete;
// 允许移动
Buffer(Buffer&& other) noexcept
: _size(other._size), _data(other._data) {
other._data = nullptr;
}
private:
size_t _size;
int* _data;
};
10. 性能考量
使用类和封装会带来一些性能考虑：
- 内联小函数：频繁调用的小函数适合内联
- 避免过度封装：简单的数据聚合可能不需要完整封装
- 对象大小：注意内存对齐和填充带来的空间开销
- 虚函数成本：虚函数调用有额外开销（虚表查找）
cpp复制// 优化前
class Point {
public:
int x() const { return _x; }
int y() const { return _y; }
private:
int _x, _y;
};
// 优化后：简单数据可直接公开
struct Point {
int x, y;
};
在实际开发中，应该先保证代码清晰和正确性，再进行有针对性的性能优化。不要为了微小的性能提升而牺牲代码的可读性和可维护性。