# 连续空间的工程封装：C++顺序表的接口设计与操作实践
顺序表是数据结构学习的起点，也是工程应用中最朴素的数据容器。连续内存布局赋予其随机访问与缓存友好的特性，而动态扩容机制使其突破静态数组的长度限制。在C++语境下实现封装的顺序表，不仅是语法练习，更是对资源管理、异常安全、接口设计等工程要素的系统审视。
## 内存布局与核心属性
顺序表底层依赖连续存储空间，需维护三个核心状态：数据指针、当前容量、实际长度：
```cpp
template
class SeqList {
private:
T* elements; // 动态数组首地址
size_t capacity; // 当前分配容量
size_t length; // 已存储元素个数
public:
SeqList(size_t init_cap = 8)
: capacity(init_cap), length(0) {
elements = new T[capacity];
}
~SeqList() {
delete[] elements;
}
// 其他成员接口...
};
```
模板参数T支持任意数据类型，初始容量设默认值避免空表状态下的频繁扩容。构造函数分配原始内存，析构函数统一释放——资源获取即初始化，资源释放集中处理，这一模式贯穿整个容器生命周期。
## 动态扩容：容量自适应的支撑机制
顺序表的动态特性源自扩容能力。当元素数量逼近容量上限时，需申请更大内存块并迁移已有数据：
```cpp
void expand(size_t new_capacity) {
if (new_capacity <= capacity) return;
T* new_elements = new T[new_capacity];
for (size_t i = 0; i < length; ++i) {
new_elements[i] = elements[i];
}
delete[] elements;
elements = new_elements;
capacity = new_capacity;
}
void push_back(const T& value) {
if (length == capacity) {
expand(capacity * 2);
}
elements[length++] = value;
}
```
扩容策略采用倍增方式，将多次插入的均摊成本控制在常数范围。异常安全需留意：内存分配失败时原数据不应受损，此处简化版本暂不涉及强异常保证。实际工程中可引入移动语义，对可移动类型提升迁移效率。
## 插入与删除：位置敏感的操作
顺序表的核心操作围绕特定位置展开。随机访问是连续存储的天然优势，但中间插入需移动后续元素：
```cpp
bool insert(size_t pos, const T& value) {
if (pos > length) return false;
if (length == capacity) {
expand(capacity * 2);
}
for (size_t i = length; i > pos; --i) {
elements[i] = elements[i - 1];
}
elements[pos] = value;
++length;
return true;
}
<"nyr.p5k3.org.cn"><"ytn.p5k3.org.cn"><"rtg.p5k3.org.cn">
bool remove(size_t pos) {
if (pos >= length) return false;
for (size_t i = pos + 1; i < length; ++i) {
elements[i - 1] = elements[i];
}
--length;
return true;
}
```
插入位置合法性校验置于方法入口，移动操作自后向前避免数据覆盖。删除后不立即缩减容量，保持已分配空间供后续使用。这种设计体现了顺序表的时间换空间特征——随机访问O(1)，中间插入删除O(n)。
## 访问接口：运算符重载与边界防护
下标访问是顺序表的标志性能力。重载operator[]提供类似数组的使用体验，同时可提供带边界检查的at版本：
```cpp
T& operator[](size_t pos) {
return elements[pos];
}
const T& operator[](size_t pos) const {
return elements[pos];
}
T& at(size_t pos) {
if (pos >= length) {
throw std::out_of_range("position out of range");
}
return elements[pos];
}
```
非const版本返回引用允许修改元素，const版本用于常量对象。operator[]舍弃边界检查换取性能，at方法以异常形式暴露安全接口——这是标准库的通行实践，将选择权交给调用者。
## 迭代器封装：指针的自然适配
顺序表的迭代器实现较链表更为简洁。连续存储使原生指针天然满足迭代器要求：
```cpp
class Iterator {
private:
T* ptr;
public:
Iterator(T* p = nullptr) : ptr(p) {}
T& operator*() { return *ptr; }
Iterator& operator++() { ++ptr; return *this; }
Iterator operator++(int) { Iterator tmp = *this; ++ptr; return tmp; }
bool operator!=(const Iterator& other) { return ptr != other.ptr; }
};
<"dgr.p5k3.org.cn"><"rht.p5k3.org.cn"><"hrt.p5k3.org.cn">
Iterator begin() { return Iterator(elements); }
Iterator end() { return Iterator(elements + length); }
```
指针自增对应内存地址递增，符合顺序表的物理布局。迭代器使顺序表能够接入基于范围的for循环，也将遍历接口从下标索引抽象为统一的迭代器协议。
## 拷贝与赋值的资源语义
顺序表管理动态数组，必须显式定义拷贝控制成员。浅拷贝将导致双指针指向同一内存，析构时重复释放：
```cpp
SeqList(const SeqList& other)
: capacity(other.capacity), length(other.length) {
elements = new T[capacity];
for (size_t i = 0; i < length; ++i) {
elements[i] = other.elements[i];
}
}
SeqList& operator=(const SeqList& other) {
if (this != &other) {
SeqList temp(other);
swap(temp);
}
return *this;
}
void swap(SeqList& other) noexcept {
std::swap(elements, other.elements);
std::swap(capacity, other.capacity);
std::swap(length, other.length);
}
```
拷贝构造函数执行深拷贝，赋值运算符采用拷贝并交换惯用法。移动构造函数与移动赋值运算符可转移指针所有权，将源对象置为空——C++11后应补充这些重载以提升效率。
## 工程视角的顺序表
顺序表在现代C++中的位置微妙。std::vector是工业级实现，其内存策略、异常安全、迭代器稳定性均经充分打磨。手写顺序表的价值不在于替代标准库，而在于理解容器设计的内在逻辑。
内存连续性决定了顺序表的优势区间——随机访问密集、增删集中于尾部的场景。每次插入引发的元素移动，都是对问题特征的适配判断。封装将这些底层操作收敛至insert、remove等核心方法，调用者无需感知元素如何迁移、容量如何调整。
从裸指针与游离的插入函数，到类封装与接口抽象，顺序表的实践路径映射着更广义的编程能力进阶。理解连续内存只是起点，构建安全、易用、高效的容器接口才是落点所在。