1. 动态数组类的设计与实现
1.1 静态数组的局限性
在C++中，静态数组的长度必须在编译时确定，这在实际开发中带来了诸多限制。比如以下代码会直接报错：
cpp复制int n = 10;
int arr[n]; // 错误：数组长度必须是常量
这种限制源于静态数组的内存分配机制。静态数组在栈上分配内存，其大小必须在编译时确定。当尝试使用变量作为数组长度时，编译器无法预知运行时该变量的值，因此拒绝编译。
1.2 动态内存分配的解决方案
C++提供了new运算符来实现动态内存分配，这是解决静态数组限制的关键：
cpp复制int n = 10;
int* p = new int[n]; // 正确：在堆上动态分配数组
这里的关键区别在于：
- new操作符在堆上分配内存，堆内存的大小可以在运行时确定
- 虽然使用了变量n，但new操作符只在执行时读取n的当前值一次
- 分配后数组大小固定，不会随n的变化而变化
1.3 封装动态数组类
将动态数组封装为类可以更好地管理资源。一个基本的动态数组类需要包含：
cpp复制class DynamicArray {
private:
int* elements; // 数组首地址指针
int size; // 数组长度
public:
DynamicArray(int n) : size(n) {
elements = new int[size];
}
~DynamicArray() {
delete[] elements;
elements = nullptr;
}
int& operator[](int index) {
return elements[index];
}
};
这个类实现了三个核心功能：
- 构造函数：根据指定大小分配内存
- 析构函数：释放内存并置空指针
- 下标运算符重载：支持数组式访问
注意：析构函数中必须使用delete[]而非delete，因为分配的是数组而非单个元素
1.4 下标运算符重载的细节
下标运算符重载需要特别注意返回值类型：
cpp复制int& operator[](int index) {
return elements[index];
}
这里返回引用(int&)而非值(int)的原因：
- 允许通过下标修改数组元素
- 避免不必要的值拷贝
- 保持与内置数组一致的行为模式
如果去掉引用，虽然读取操作仍然有效，但赋值操作会失败：
cpp复制DynamicArray arr(10);
arr[0] = 5; // 无引用时此操作将报错
2. 类模板的实现与应用
2.1 从特定类型到通用类型
前面的DynamicArray只能处理int类型，要支持多种类型，类模板是最佳选择。类模板语法与函数模板类似：
cpp复制template<typename T>
class DynamicArray {
// 类定义...
};
这里typename T表示一个占位类型，可以用class替代typename，两者在模板定义中等价。
2.2 模板类中的类型替换
在转换为模板类时，需要谨慎选择哪些类型应该被替换：
cpp复制template<typename T>
class DynamicArray {
private:
T* elements; // 元素类型变为T
int size; // 长度保持int
public:
DynamicArray(int n) : size(n) {
elements = new T[size]; // 分配T类型数组
}
T& operator[](int index) { // 返回类型变为T&
return elements[index];
}
};
需要保持为int的类型：
- 数组长度（size）
- 下标索引（index）
因为这些本质上都是计数/索引，与元素类型无关。
2.3 模板类的实例化
使用模板类时需要显式指定类型参数：
cpp复制DynamicArray<int> intArr(10); // int类型数组
DynamicArray<char> charArr(100); // char类型数组
实例化过程分为两步：
- 编译器根据模板生成特定类型的类定义
- 创建该类的对象实例
2.4 类模板的成员函数定义
类模板的成员函数可以在类内或类外定义。类外定义时需要特殊语法：
cpp复制// 类内声明
template<typename T>
class DynamicArray {
public:
void update(int index, T value);
};
// 类外定义
template<typename T>
void DynamicArray<T>::update(int index, T value) {
elements[index] = value;
}
关键点：
- 每个成员函数前都需要template声明
- 类名后要带模板参数DynamicArray
- 作用域解析符::前是完整类名
3. 类模板的高级特性
3.1 延迟实例化机制
类模板的成员函数采用"按需实例化"策略：
cpp复制template<typename T>
class Test {
public:
void func1() { T::undefined(); } // 明显错误
void func2() { /* 正常实现 */ }
};
Test<int> t; // 此时不会报错
t.func2(); // 只实例化func2
// t.func1(); // 只有调用时才会报错
这种机制的优势：
- 允许模板包含可能不适用的成员函数
- 只有实际使用的函数会被检查语法
- 提高了模板的灵活性和复用性
3.2 类模板作为函数参数
当需要将模板类对象传递给函数时，有三种处理方式：
3.2.1 显式指定类型
cpp复制void process(DynamicArray<int>& arr) {
// 处理int数组
}
优点：简单直接
缺点：每种类型需要单独函数
3.2.2 参数模板化
cpp复制template<typename T>
void process(DynamicArray<T>& arr) {
// 通用处理逻辑
}
优点：一个函数处理所有类型
缺点：函数内部不能假设具体类型
3.2.3 类模板化
cpp复制template<typename C>
void process(C& container) {
// 通用容器处理
}
最灵活的方式，适用于任何支持所需操作的类
3.3 类模板的继承
类模板也可以作为基类被继承：
cpp复制template<typename T>
class Base {
// 基类实现
};
// 派生类指定具体类型
class DerivedInt : public Base<int> {
// 实现
};
// 或者派生类也是模板
template<typename T, typename U>
class DerivedTemplate : public Base<T> {
// 实现
};
继承时的注意事项：
- 派生类可以选择固定基类模板参数
- 也可以将派生类自身作为模板
- 可以添加新的模板参数扩展功能
4. 实战技巧与常见问题
4.1 动态数组的边界检查
原始实现缺少边界检查，可能导致越界访问。改进方案：
cpp复制T& operator[](int index) {
if (index < 0 || index >= size) {
throw std::out_of_range("Index out of bounds");
}
return elements[index];
}
4.2 内存管理最佳实践
- 遵循RAII原则：资源获取即初始化
- 禁用拷贝构造函数和赋值运算符，或实现深拷贝
- 考虑使用std::unique_ptr管理内存
cpp复制template<typename T>
class DynamicArray {
private:
std::unique_ptr<T[]> elements;
// ...
public:
DynamicArray(int n) : elements(new T[n]), size(n) {}
// 不再需要显式析构函数
};
4.3 性能优化建议
- 预分配足够空间减少重新分配
- 实现移动语义支持高效转移
- 对小数组考虑SSO(小字符串优化)技术
cpp复制template<typename T>
class DynamicArray {
public:
DynamicArray(DynamicArray&& other) noexcept
: elements(other.elements), size(other.size) {
other.elements = nullptr;
other.size = 0;
}
};
4.4 常见错误排查
- 内存泄漏：确保每个new都有对应的delete[]
- 野指针：析构后置空指针
- 越界访问：实现边界检查
- 类型不匹配：确保模板实例化类型正确
我在实际项目中曾遇到一个典型问题：在类模板中混合使用了模板参数和固定类型时，容易混淆哪些应该替换为模板参数。一个实用的检查方法是：问自己"这个成员/参数是否应该随实例化类型变化"，如果答案是肯定的，就应该使用模板参数T。