# 对象协作：C++面向对象思想下的单链表实现与操作实践
单链表是数据结构中指针操作的经典范本。然而在C++语境下，单纯实现节点连接与遍历远非终点。面向对象的封装、职责划分、资源管理才是将“能工作的代码”提升为“可复用的组件”的关键环节。单链表的面向对象设计，核心问题并非指针如何指向，而是节点与链表各自承担何种职责、边界划于何处。
## 职责分离：节点类与链表类的协作
单链表的面向对象实现应从两个类的协作开始。节点类存储数据与后继指针，链表类管理头节点与操作接口：
```cpp
template
class Node {
public:
T data;
Node* next;
Node(const T& value) : data(value), next(nullptr) {}
Node(T&& value) : data(std::move(value)), next(nullptr) {}
};
template
class SingleList {
private:
Node
size_t size;
public:
SingleList() : head(nullptr), size(0) {}
~SingleList() { clear(); }
void push_front(const T& value);
void pop_front();
void clear();
// 其他接口...
};
```
节点类将数据与指针设为公有。这并非封装失当，而是承认节点仅是链表内部的数据载体，无需对外隐藏细节。链表类维护头指针与节点计数，对外提供语义清晰的容器操作。职责边界明确：节点负责链接关系，链表负责生命周期与访问控制。
## 头节点策略：简化边界操作
单链表操作中，空表状态与首节点操作是边界条件的集中区域。引入哑头节点可使代码统一处理：
```cpp
template
class SingleList {
private:
Node
size_t size;
public:
SingleList() {
dummy_head = new Node
dummy_head->next = nullptr;
size = 0;
}
~SingleList() {
clear();
delete dummy_head;
}
};
```
哑头节点始终存在，其data字段闲置，next指向首节点或空。插入删除不再需要区分是否操作头节点，所有位置的操作模式统一。这是空间换思想的典型实践——消耗一个节点的存储，换取边界逻辑的简化。
## 插入操作：前驱定位与指针重连
单链表的插入必须定位目标位置的前驱节点。基于哑头节点的实现使这一操作通用于所有位置：
```cpp
bool insert(size_t pos, const T& value) {
if (pos > size) return false;
<"hbr.p5k3.org.cn"><"thb.p5k3.org.cn"><"rew.p5k3.org.cn">
Node
for (size_t i = 0; i < pos; ++i) {
prev = prev->next;
}
Node
newNode->next = prev->next;
prev->next = newNode;
++size;
return true;
}
void push_front(const T& value) {
insert(0, value);
}
void push_back(const T& value) {
insert(size, value);
}
```
前驱遍历与指针重连是单链表插入的标准步骤。insert方法统一处理所有位置，push_front与push_back作为特例调用即可。代码复用程度提升，维护多个插入变体的心智负担下降。
## 删除操作：内存释放与指针调整
删除操作同样依赖前驱定位，区别在于需额外保存待删节点地址用于释放：
```cpp
bool remove(size_t pos) {
if (pos >= size) return false;
Node
for (size_t i = 0; i < pos; ++i) {
prev = prev->next;
}
Node
prev->next = toDelete->next;
delete toDelete;
--size;
return true;
}
void pop_front() {
remove(0);
}
```
先调整指针，再释放内存——顺序不可颠倒。哑头节点使首节点删除与中间节点删除采用完全相同的代码路径，无需特殊处理头指针为空或仅有一个节点的场景。
## 遍历与查询：迭代器模式的引入
裸指针遍历暴露节点细节，迭代器提供更高层抽象：
```cpp
template
class SingleList {
public:
class Iterator {
Node
public:
Iterator(Node
T& operator*() { return ptr->data; }
Iterator& operator++() { ptr = ptr->next; return *this; }
bool operator!=(const Iterator& other) { return ptr != other.ptr; }
};
Iterator begin() { return Iterator(dummy_head->next); }
Iterator end() { return Iterator(nullptr); }
<"gre.p5k3.org.cn"><"otr.p5k3.org.cn"><"rth.p5k3.org.cn">
Iterator find(const T& value) {
Node
while (current) {
if (current->data == value) {
return Iterator(current);
}
current = current->next;
}
return end();
}
};
```
迭代器封装了指针前进操作，使链表支持基于范围的for循环。find方法返回迭代器，统一了查找与访问的接口风格。成功时指向目标节点，失败时返回end——这是STL容器的通行惯例。
## 资源管理：三五法则的完整实现
链表涉及动态内存，必须显式管理拷贝与赋值：
```cpp
SingleList(const SingleList& other) : SingleList() {
Node
while (current) {
push_back(current->data);
current = current->next;
}
}
SingleList& operator=(const SingleList& other) {
if (this != &other) {
SingleList temp(other);
swap(temp);
}
return *this;
}
void swap(SingleList& other) noexcept {
std::swap(dummy_head, other.dummy_head);
std::swap(size, other.size);
}
```
拷贝构造函数委托默认构造函数创建哑头节点，再逐个尾插元素。赋值运算符采用拷贝并交换惯用法，异常安全且代码简洁。移动构造函数与移动赋值运算符可转移指针所有权，将源链表置空——C++11后应予补充。
## 面向对象设计的价值
单链表的面向对象实现，核心产出并非另一个可用链表，而是对“职责”与“协作”的具象理解。Node管理链接关系却不关心内存生命周期，SingleList管理头节点与容量却不干预指针操作细节。两个类通过约定的接口协作，各自保持内聚。
指针操作仍是单链表的技术难点。但面向对象将其收敛于insert、remove、clear等少数私有方法或底层辅助函数，对外呈现的是push、pop、begin、end等容器语义。使用者操作链表而非操作节点，操作迭代器而非操作指针。
这是数据结构的工程化蜕变——从“如何实现功能”到“如何设计接口”，从“指针如何指”到“对象如何协作”。单链表作为载体，承载的是程序员的抽象能力进阶之路。