我的128天创作之路：回顾与展望

news2025/1/13 13:05:55

大家好呀！今天来和你们分享一下我的创作历程😁。

一、机缘

最开始创作呢，是因为在学习 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 的原理帮助很大，也让我的技术水平提升了不少呢！