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

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


一、机缘

最开始创作呢,是因为在学习 C++ 的 STL 时,像 string、list、vector 这些模板可把我折腾得够呛,但也让我学到了超多东西!我就想,要是把我对它们的理解和实践经验写下来,既能巩固自己的知识,又能帮到其他正在学习的小伙伴,多好呀!于是,我就满怀热情地踏上了创作之路,希望能在这个平台上和大家一起进步,愉快地交流技术🤝。

二、收获

在创作的过程中,真的收获满满!我的文章有了不少阅读量,每次看到有小伙伴看我的分享,心里就特别开心😄。还有读者给我点赞👍和评论,这些都给了我极大的鼓励,让我知道我的努力是有价值的。通过和读者互动,我还结识了好多志同道合的朋友,我们一起探讨技术难题,让我的技术视野变得更开阔啦!

多家社区收录文章

获得官方奖励

全站热榜第一

三、日常

现在,创作已经成为我生活中不可或缺的一部分啦。坚持每俩天创作一篇,虽然平时工作和学习挺忙的,但我会合理安排时间,利用业余时间来创作。我发现创作和工作学习是相互促进的,在创作时,我会对知识进行更深入的思考和总结,这让我的专业能力不断提升;而工作学习中的新收获又为我的创作提供了丰富的素材,真是太棒啦!

四、成就

在学习 C++ 的过程中,我成功实现了一些 STL 模板的功能哦,给大家展示一下部分关键代码,并加上注释方便理解。

首先是 MyString 类,它类似于 std::string

cpp 复制代码
#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,这里展示节点、迭代器的定义和插入操作:

cpp 复制代码
// 链表节点结构体模板,存储数据和前后指针
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,比如构造函数、扩容机制和元素访问:

cpp 复制代码
// 自定义向量类模板
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】