大家好呀！今天来和你们分享一下我的创作历程😁。
一、机缘
最开始创作呢，是因为在学习 C++ 的 STL 时，像 string、list、vector 这些模板可把我折腾得够呛，但也让我学到了超多东西！我就想，要是把我对它们的理解和实践经验写下来，既能巩固自己的知识，又能帮到其他正在学习的小伙伴，多好呀！于是，我就满怀热情地踏上了创作之路，希望能在这个平台上和大家一起进步，愉快地交流技术🤝。
二、收获
在创作的过程中，真的收获满满！我的文章有了不少阅读量，每次看到有小伙伴看我的分享，心里就特别开心😄。还有读者给我点赞👍和评论，这些都给了我极大的鼓励，让我知道我的努力是有价值的。通过和读者互动，我还结识了好多志同道合的朋友，我们一起探讨技术难题，让我的技术视野变得更开阔啦！
多家社区收录文章
获得官方奖励
全站热榜第一
三、日常
现在，创作已经成为我生活中不可或缺的一部分啦。坚持每俩天创作一篇，虽然平时工作和学习挺忙的，但我会合理安排时间，利用业余时间来创作。我发现创作和工作学习是相互促进的，在创作时，我会对知识进行更深入的思考和总结，这让我的专业能力不断提升；而工作学习中的新收获又为我的创作提供了丰富的素材，真是太棒啦！
四、成就
在学习 C++ 的过程中，我成功实现了一些 STL 模板的功能哦，给大家展示一下部分关键代码，并加上注释方便理解。
首先是 MyString 类，它类似于 std::string：
#include <iostream>
#include <cstring>
class MyString {
private:
char* data;
size_t len;
public:
MyString() : data(nullptr), len(0) {}
MyString(const char* str) {
len = std::strlen(str);
data = new char[len + 1];
std::strcpy(data, str);
}
~MyString() {
delete[] data;
}
size_t length() const {
return len;
}
char& operator[](size_t index) {
return data[index];
}
const char& operator[](size_t index) const {
return data[index];
}
MyString& operator=(const MyString& other) {
if (this!= &other) {
delete[] data;
len = other.len;
data = new char[len + 1];
std::strcpy(data, other.data);
}
return *this;
}
MyString operator+(const MyString& other) const {
char* newData = new char[len + other.len + 1];
std::strcpy(newData, data);
std::strcat(newData, other.data);
MyString result(newData);
delete[] newData;
return result;
}
};接着是 MyList 类，类似 std::list，这里展示节点、迭代器的定义和插入操作：
// 链表节点结构体模板，存储数据和前后指针
template<typename T>
struct ListNode {
T data;
ListNode<T>* next;
ListNode<T>* prev;
ListNode(const T& value) : data(value), next(nullptr), prev(nullptr) {}
};
// 链表迭代器模板类，用于遍历链表
template<typename T>
class ListIterator {
private:
ListNode<T>* node;
public:
// 构造函数，初始化迭代器指向的节点
ListIterator(ListNode<T>* n) : node(n) {}
// 重载解引用运算符，返回当前节点存储的数据
T& operator*() {
return node->data;
}
// 前置递增运算符重载，将迭代器指向下一个节点
ListIterator<T>& operator++() {
node = node->next;
return *this;
}
// 比较运算符重载，判断两个迭代器是否不相等
bool operator!=(const ListIterator<T>& other) {
return node!= other.node;
}
};
// 自定义链表类模板
template<typename T>
class MyList {
private:
ListNode<T>* head; // 链表头节点指针
ListNode<T>* tail; // 链表尾节点指针
public:
MyList() : head(nullptr), tail(nullptr) {}
~MyList() {
// 释放链表所有节点的内存
while (head!= nullptr) {
ListNode<T>* next = head->next;
delete head;
head = next;
}
}
// 在链表尾部插入元素
void push_back(const T& value) {
ListNode<T>* newNode = new ListNode<T>(value);
if (tail == nullptr) {
head = tail = newNode;
} else {
newNode->prev = tail;
tail->next = newNode;
tail = newNode;
}
}
// 返回链表的起始迭代器
ListIterator<T> begin() {
return ListIterator<T>(head);
}
// 返回链表的结束迭代器（指向空节点）
ListIterator<T> end() {
return ListIterator<T>(nullptr);
}
};
还有 MyVector 类，类似 std::vector，比如构造函数、扩容机制和元素访问：
// 自定义向量类模板
template<typename T>
class MyVector {
private:
T* data; // 存储元素的数组
size_t capacity; // 向量的容量
size_t size; // 向量中实际元素的个数
// 扩容函数，重新分配内存并复制元素
void resize(size_t newCapacity) {
T* newData = new T[newCapacity];
for (size_t i = 0; i < size; ++i) {
newData[i] = data[i];
}
delete[] data;
data = newData;
capacity = newCapacity;
}
public:
MyVector() : data(nullptr), capacity(0), size(0) {}
// 带初始容量的构造函数
MyVector(size_t initialCapacity) : capacity(initialCapacity), size(0) {
data = new T[capacity];
}
~MyVector() {
delete[] data;
}
// 在向量尾部插入元素，如果容量不足则扩容
void push_back(const T& value) {
if (size == capacity) {
resize(capacity == 0? 1 : capacity * 2);
}
data[size++] = value;
}
// 重载下标运算符，用于访问向量中的元素（非 const 版本）
T& operator[](size_t index) {
return data[index];
}
// 重载下标运算符，用于访问向量中的元素（const 版本）
const T& operator[](size_t index) const {
return data[index];
}
// 返回向量中实际元素的个数
size_t length() const {
return size;
}
};
这些实现虽然只是基础的框架，但在学习过程中对我理解 STL 的原理帮助很大，也让我的技术水平提升了不少呢！
五、憧憬
在未来，我希望能在技术领域继续深入学习和实践，把这些实现进一步优化，然后分享给更多的小伙伴。在职业规划上，我想成为一名厉害的软件工程师，用我的技术解决实际问题，为项目出份力💪。我也会坚持创作，不断提高写作能力和技术水平，给读者带来更有价值的内容。我相信只要努力，一定能实现目标的，加油！
欢迎关注，让我们共同进步👉【A charmer】
