仿制std::vector

最新推荐文章于 2024-05-11 12:12:17 发布
最新推荐文章于 2024-05-11 12:12:17 发布
阅读量54 收藏
点赞数 1
文章标签： c++ 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/q1145141/article/details/134573920
版权

我的想法是用一个指针保存数据，再用两个int保存最大容量和当前容量

template<typename T>
class vec
{
    T* value;
    int Size;
    int MaxSize;
public:
}

考虑到要实现迭代器，就先把迭代器放上

template<typename T>
class vec
{
    class iterator
    {
    protected:
        T* ptr;
    public:
        iterator(T* data);
        iterator operator++();
        iterator operator--();
        iterator operator+(int Val)const;
        iterator operator-(int Val)const;
        T* operator->()const;
        T& operator*()const;
        bool operator==(const iterator& rhs)const;
        bool operator!=(const iterator& rhs)const;
        ~iterator();
    };
    T* value;
    int Size;
    int MaxSize;
public:
}

首先是构造函数

template<typename T>
template<typename ...Y>
vec<T>::vec(const T& data, const Y&...datas)
{
    int s = sizeof...(datas);
    value = new T[s + 1]{ data,datas... };
    MaxSize = s + 1;
    Size = MaxSize;
}

sizeof...(datas)可以获取可变参数的数量，算上data，一共是s+1个数据

还有无参的构造函数

template<typename T>
vec<T>::vec()
    :Size(0), MaxSize(0), value(new T[0])
{

}

析构函数没什么好说的

template<typename T>
vec<T>::~vec()
{
    delete[] value;
    value = nullptr;
}

把value设置为nullptr，防止有某个指针指向value多次delete

delete nullptr是完全合法的

接下来实现一些简单的函数

template<typename T>
int vec<T>::size()const
{
    return Size;
}
template<typename T>
int vec<T>::max_size()const
{
    return MaxSize;
}

vector用的接口是capacity，但是像我这种不懂英文的还是max_size更直观一点

时间复杂度和空间复杂度都是O(1)

为了实现数组的随机访问，需要实现这两个函数

template<typename T>
T& vec<T>::operator[](int index)
{
    return value[index];
}
template<typename T>
const T& vec<T>::operator[](int index)const
{
    return value[index];
}

虽然看起来一样，但第一个返回的是引用，可以修改值，第二个是常量引用，不能修改值

同样的，时间复杂度和空间复杂度都是O(1)

同样的还有at函数

template<typename T>
const T& vec<T>::at(int index)const
{
    if (index < 0 || index >= Size)
    {
        std::cerr << "vec at错误,下标为" << index;
        std::abort();
    }
    return value[index];
}

at函数会检查下标是否正确，而operator[]不会

有了这些就可以实现复制构造函数了

template<typename T>
vec<T>::vec(const vec& rhs)
{
    value = new T[rhs.max_size()];
    for (int i = 0; i < rhs.size(); ++i)
    {
        value[i] = rhs[i];
    }
    Size = rhs.size();
    MaxSize = rhs.max_size();
}

由于储存数据的是指针，自动生成的构造函数使用的是浅拷贝，需要手动写一个深拷贝的复制构造函数

//修改Size的大小
template<typename T>
void vec<T>::resize(int NewSize, const T& Val)
{
    //如果本身的最大容量大于新的容量，只改变Size的大小
    if (MaxSize >= NewSize)
    {
        Size = NewSize;
        return;
    }
    //最大容量小于新容量了，需要扩容
    MaxSize = NewSize;
    T* v = new T[MaxSize];
    //先把每个值初始化为Val，原值覆盖后多余的就自动变成Val了
    //其实也可以原值覆盖后再填充Val,但是时间复杂度都是O(n)动不动都一样
    for (int i = 0; i < Size; ++i)
    {
        v[i] = value[i];
    }
    for (int i = Size; i < NewSize; ++i)
    {
        v[i] = Val;
    }
    Size = NewSize;
    delete[] value;
    value = v;
}
//修改MaxSize的大小
template<typename T>
void vec<T>::reserve(int NewSize)
{
    //新容量小于当前最大容量，什么也不用做
    if (NewSize <= MaxSize)
    {
        return;
    }
    //容量不足
    T* v = new T[NewSize]; 
    //只需要拷贝前Size个数据就可以
    for (int i = 0; i < Size; ++i)
    {
        v[i] = value[i];
    }
    delete[]value;
    value = v;
    MaxSize = NewSize;
}

两个修改容量的函数

需要注意要释放不用的内存

时间复杂度和空间复杂度都是O(n)

template<typename T>
void vec<T>::clear()
{
    Size = 0;
}
template<typename T>
bool vec<T>::empty()const
{
    return Size == 0;
}
template<typename T>
T* vec<T>::data()const
{
    return value;
}

这几个没什么好说的

时间复杂度和空间复杂度都是O(1)

//在末尾添加一个值
template<typename T>
void vec<T>::push_back(const T& Val)
{
    //判断容量是否够用
    if (Size + 1 > MaxSize)
    {
        //容量不够了，申请新的空间
        T* v = new T[Size + 1];
        ++Size;
        ++MaxSize;
        //复制原本的值
        for (int i = 0; i < Size; ++i)
        {
            v[i] = value[i];
        }
        v[Size - 1] = Val;
        delete[]value;
        value = v;
        return;
    }
    //容量足够，直接赋值即可
    value[Size] = Val;
    ++Size;
}
//删除末尾的一个值
template<typename T>
void vec<T>::pop_back()
{
    //不需要删除元素，只需要把Size递减就够了
    --Size;
}

push_back()时间复杂度和空间复杂度都是O(n)

pop_back()时间复杂度和空间复杂度都是O(1)

pop_back()可能不好理解，想一想，平时遍历vector的时候，是不是这么写的

int main()
{
    std::vector<int> v;
    for (int i = 0; i < v.size(); ++i)
    {
        std::cout << v[i] << ' ';
    }
    return 0;
}

只需要把Size-1，就能少遍历一次，就相当于删除了末尾的元素

当然用迭代器的话也是没有问题的，现在实现迭代器

template<typename T>
vec<T>::iterator::iterator(T* data)
{
    ptr = data;
}
template<typename T>
vec<T>::iterator vec<T>::iterator::operator++()
{
    ++ptr;
    return *this;
}
template<typename T>
vec<T>::iterator vec<T>::iterator::operator--()
{
    --ptr;
    return *this;
}
template<typename T>
vec<T>::iterator vec<T>::iterator::operator+(int Val)const
{
    return iterator(ptr + Val);
}
template<typename T>
vec<T>::iterator vec<T>::iterator::operator-(int Val)const
{
    return iterator(ptr - Val);
}
template<typename T>
T* vec<T>::iterator::operator->()const
{
    return ptr;
}
template<typename T>
T& vec<T>::iterator::operator*()const
{
    return *ptr;
}
template<typename T>
bool vec<T>::iterator::operator==(const vec<T>::iterator& rhs)const
{
    return ptr == rhs.ptr;
}
template<typename T>
bool vec<T>::iterator::operator!=(const vec<T>::iterator& rhs)const
{
    return ptr != rhs.ptr;
}

template<typename T>
vec<T>::iterator::~iterator()
{

}

迭代器的代码算是比较简单的

构造函数只是把原本的value复制一份

由于数组在内存的分布是连续的，只需要增减指针就可以实现下标的增减

这个迭代器是同时具备顺序和逆序的，也可以把顺序逆序分开写，但我为了方便集合到一个迭代器里了

template<typename T>
vec<T>::iterator vec<T>::begin()const
{
    return iterator(value);
}
template<typename T>
vec<T>::iterator vec<T>::rbegin()const
{
    return iterator(value + Size - 1);
}
template<typename T>
vec<T>::iterator vec<T>::end()const
{
    return iterator(value + Size);
}
template<typename T>
vec<T>::iterator vec<T>::rend()const
{
    return iterator(value - 1);
}

不知道为什么，在我写cbegin()的时候，这么写会报错

template<typename T>
const vec<T>::iterator vec<T>::cbegin()const
{
    return iterator(value);
}

请大佬解答一下，感谢感谢

//替换成first到last
template<typename T>
void vec<T>::assign(iterator first, iterator last)
{
    //遍历一遍，查看需要多大的空间
    int n = 0;
    for (auto a = first; a != last; ++a)
    {
        ++n;
    }
    //如果空间不足
    if (n > MaxSize)
    {
        delete[]value;
        value = new T[n];
        MaxSize = n;
    }
    Size = n;
    int b = 0;
    //赋值
    for (auto a = first; a != last; ++a)
    {
        value[b] = *a;
        ++b;
    }

}
//替换成n个x
template<typename T>
void vec<T>::assign(int n, const T& x)
{
    //空间不足
    if (n > MaxSize)
    {
        delete[] value;
        value = new T[n];
        MaxSize = n;
    }
    Size = n;
    //赋值
    for (int i = 0; i < n; ++i)
    {
        value[i] = x;
    }
}
//插入元素
template<typename T>
vec<T>::iterator vec<T>::insert(vec<T>::iterator Where, const T& Val)
{
    //插入后Size肯定会增加
    int n = Size + 1;
    //空间不足
    if (n > MaxSize)
    {
        T* v = new T[n];
        int j = 0;
        //重新赋值
        for (auto i = begin(); i != end(); ++i, ++j)
        {
            //如果遍历到插入的位置
            //递增一次
            if (i == Where)
            {
                v[j] = Val;
                ++j;
            }
            v[j] = *i;
        }
        MaxSize = Size + 1 > MaxSize ? Size + 1 : MaxSize;
        ++Size;
        delete[] value;
        value = v;
        return Where;
    }
    //使最后一个元素为Val
    if (Size != 0)
    {
        value[Size - 1] = Val;
    }
    else
    {
        value[Size] = Val;
    }
    //空间足够
    for (auto i = rbegin(); i != rend(); --i)
    {
        //把Val从最后向前移动
        if (i != Where)
        {
            std::swap(*i, *(i - 1));
        }
        //移动到应该在的位置了
        else
        {
            ++Size;
            return Where;
        }
    }
    //rbegin()和rend()有可能相同
    ++Size;
    return Where;
}
//移除元素
template<typename T>
void vec<T>::erase(iterator Where)
{
    for (auto i = Where; i != end() - 1; ++i)
    {
        if (i == Where)
        {
            不断把元素向后移动
            std::swap(*i, *(i + 1));
            ++Where;
        }
    }
    --Size;
}

assign和insert时间复杂度和空间复杂度都是O(n)

erase时间复杂度O(n)，空间复杂度O(1)

接下来是整体代码

#include <algorithm>
#include <iostream>
template<typename T>
class vec
{
    class iterator
    {
    protected:
        T* ptr;
    public:
        iterator(T* data);
        iterator operator++();
        iterator operator--();
        iterator operator+(int Val)const;
        iterator operator-(int Val)const;
        T* operator->()const;
        T& operator*()const;
        bool operator==(const iterator& rhs)const;
        bool operator!=(const iterator& rhs)const;
        ~iterator();
    };
    T* value;
    int Size;
    int MaxSize;
public:
    vec();
    template<typename ...Y>
    vec(const T& data, const Y& ...datas);
    vec(const vec& rhs);
    void assign(iterator first, iterator last);
    void assign(int n, const T& x = 0);
    iterator insert(iterator Where, const T& Val);
    void erase(iterator Where);
    void push_back(const T& Val);
    void pop_back();
    void resize(int NewSize, const T& Val = 0);
    void reserve(int NewSize);
    iterator begin()const;
    iterator rbegin()const;
    iterator end()const;
    iterator rend()const;
    const T& at(int index)const;
    T& front()const;
    T& back()const;
    int size()const;
    int max_size()const;
    void clear();
    bool empty()const;
    T* data()const;
    T& operator[](int index);
    const T& operator[](int index)const;
    vec& operator=(const vec& rhs);
    ~vec();
};
template<typename T>
vec<T>::iterator::iterator(T* data)
{
    ptr = data;
}
template<typename T>
vec<T>::iterator vec<T>::iterator::operator++()
{
    ++ptr;
    return *this;
}
template<typename T>
vec<T>::iterator vec<T>::iterator::operator--()
{
    --ptr;
    return *this;
}
template<typename T>
vec<T>::iterator vec<T>::iterator::operator+(int Val)const
{
    return iterator(ptr + Val);
}
template<typename T>
vec<T>::iterator vec<T>::iterator::operator-(int Val)const
{
    return iterator(ptr - Val);
}
template<typename T>
T* vec<T>::iterator::operator->()const
{
    return ptr;
}
template<typename T>
T& vec<T>::iterator::operator*()const
{
    return *ptr;
}
template<typename T>
bool vec<T>::iterator::operator==(const vec<T>::iterator& rhs)const
{
    return ptr == rhs.ptr;
}
template<typename T>
bool vec<T>::iterator::operator!=(const vec<T>::iterator& rhs)const
{
    return ptr != rhs.ptr;
}

template<typename T>
vec<T>::iterator::~iterator()
{

}
template<typename T>
vec<T>::vec()
    :Size(0), MaxSize(0), value(new T[0])
{

}
template<typename T>
template<typename ...Y>
vec<T>::vec(const T& data, const Y&...datas)
{
    int s = sizeof...(datas);
    value = new T[s + 1]{ data,datas... };
    MaxSize = s + 1;
    Size = MaxSize;
}
template<typename T>
vec<T>::vec(const vec& rhs)
{
    value = new T[rhs.max_size()];
    for (int i = 0; i < rhs.size(); ++i)
    {
        value[i] = rhs[i];
    }
    Size = rhs.size();
    MaxSize = rhs.max_size();
}
template<typename T>
void vec<T>::assign(iterator first, iterator last)
{
    int n = 0;
    for (auto a = first; a != last; ++a)
    {
        ++n;
    }
    if (n > MaxSize)
    {
        delete[]value;
        value = new T[n];
        MaxSize = n;
    }
    Size = n;
    int b = 0;
    for (auto a = first; a != last; ++a)
    {
        value[b] = *a;
        ++b;
    }

}
template<typename T>
void vec<T>::assign(int n, const T& x)
{
    if (n > MaxSize)
    {
        delete[] value;
        value = new T[n];
        MaxSize = n;
    }
    Size = n;
    for (int i = 0; i < n; ++i)
    {
        value[i] = x;
    }
}
template<typename T>
vec<T>::iterator vec<T>::insert(vec<T>::iterator Where, const T& Val)
{
    int n = Size + 1;
    if (n > MaxSize)
    {
        T* v = new T[n];
        int j = 0;
        for (auto i = begin(); i != end(); ++i, ++j)
        {
            if (i == Where)
            {
                v[j] = Val;
                ++j;
            }
            v[j] = *i;
        }
        MaxSize = Size + 1 > MaxSize ? Size + 1 : MaxSize;
        ++Size;
        delete[] value;
        value = v;
        return Where;
    }
    if (Size != 0)
    {
        value[Size - 1] = Val;
    }
    else
    {
        value[Size] = Val;
    }
    for (auto i = rbegin(); i != rend(); --i)
    {
        if (i != Where)
        {
            std::swap(*i, *(i - 1));
        }
        else
        {
            ++Size;
            return Where;
        }
    }
    ++Size;
    return Where;
}
template<typename T>
void vec<T>::erase(iterator Where)
{
    for (auto i = Where; i != end() - 1; ++i)
    {
        if (i == Where)
        {
            std::swap(*i, *(i + 1));
            ++Where;
        }
    }
    --Size;
}
template<typename T>
void vec<T>::push_back(const T& Val)
{
    if (Size + 1 > MaxSize)
    {
        T* v = new T[Size + 1];
        ++Size;
        ++MaxSize;
        for (int i = 0; i < Size; ++i)
        {
            v[i] = value[i];
        }
        v[Size - 1] = Val;
        delete[]value;
        value = v;
        return;
    }
    value[Size] = Val;
    ++Size;
}
template<typename T>
void vec<T>::pop_back()
{
    --Size;
}
template<typename T>
void vec<T>::resize(int NewSize, const T& Val)
{
    if (MaxSize >= NewSize)
    {
        Size = NewSize;
        return;
    }
    MaxSize = NewSize;
    T* v = new T[MaxSize];
    for (int i = 0; i < Size; ++i)
    {
        v[i] = value[i];
    }
    for (int i = Size; i < NewSize; ++i)
    {
        v[i] = Val;
    }
    Size = NewSize;
    delete[] value;
    value = v;
}
template<typename T>
void vec<T>::reserve(int NewSize)
{
    if (NewSize <= MaxSize)
    {
        return;
    }
    T* v = new T[NewSize];
    for (int i = 0; i < Size; ++i)
    {
        v[i] = value[i];
    }
    delete[]value;
    value = v;
    MaxSize = NewSize;
}
template<typename T>
vec<T>::iterator vec<T>::begin()const
{
    return iterator(value);
}
template<typename T>
vec<T>::iterator vec<T>::rbegin()const
{
    return iterator(value + Size - 1);
}
template<typename T>
vec<T>::iterator vec<T>::end()const
{
    return iterator(value + Size);
}
template<typename T>
vec<T>::iterator vec<T>::rend()const
{
    return iterator(value - 1);
}
template<typename T>
const T& vec<T>::at(int index)const
{
    if (index < 0 || index >= Size)
    {
        std::cerr << "vec at错误,下标为" << index;
        std::abort();
    }
    return value[index];
}
template<typename T>
T& vec<T>::front()const
{
    return value[0];
}
template<typename T>
T& vec<T>::back()const
{
    return value[Size - 1];
}
template<typename T>
int vec<T>::size()const
{
    return Size;
}
template<typename T>
int vec<T>::max_size()const
{
    return MaxSize;
}
template<typename T>
void vec<T>::clear()
{
    Size = 0;
}
template<typename T>
bool vec<T>::empty()const
{
    return Size == 0;
}
template<typename T>
T* vec<T>::data()const
{
    return value;
}
template<typename T>
T& vec<T>::operator[](int index)
{
    return value[index];
}
template<typename T>
const T& vec<T>::operator[](int index)const
{
    return value[index];
}
template<typename T>
vec<T>& vec<T>::operator=(const vec<T>& rhs)
{
    delete[] value;
    value = new T[rhs.max_size()];
    for (int i = 0; i < rhs.size(); ++i)
    {
        value[i] = rhs[i];
    }
    return *this;
}
template<typename T>
vec<T>::~vec()
{
    delete[] value;
    value = nullptr;
}

有错误请大佬指正！

咸鱼就该躺平
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
imitateWangYiYun:仿制网易云
05-04
imitateWangYiYun###仿制网易云将采用VUE仿照网易云音乐做一个mobile端播发器。（接口来自于网易云）cd wyy
仿Vector模板类
qq_65394904的博客
12-10 75
【代码】仿Vector模板类。
使用Qt制作网易云播放器的歌曲排行界面
m0_51415606的博客
12-15 761
本篇的目的就是介绍红色方框的界面怎么做。代码非常简单，就不详细介绍了。网易云排行榜的歌曲排行界面。
c++ primer复习(3)那些太容易被忽略的细节(持续更新)
普雷的博客
12-30 808
1.std::endl 有一个作用是来冲洗buffer 2.声明语句时理解方式 typedef char* pstring; //这两看似一样，但是实际不同 const pstring cstr = 0; //char*为基本数据类型 const char* cstr = 0; //char 为基本数据类型，*变成声明 3.auto声明 多条声明语句类型必须一致 auto i=0,*p=&i; 4.std::size_t 是一种std::string里内置的变量类型,是无符号的,所以要小心跟
Apollo 6.0 perception 瞎学笔记（四）激光雷达lidar结合opendrive地图数据roi滤波单元测试
YP233的博客
05-06 1450
Apollo 6.0 perception 瞎学笔记（四）激光雷达lidar结合opendrive地图数据roi滤波单元测试目录1.scene_manager_test.cc 目录 前面我们瞎学了apollo感知部分bitmap2d和hdmap_roi_filter，现在我们瞎学一下apollo关于《通过高精地图信息来对激光雷达数据roi滤波》的单元测试部分。代码位于apollo-r6.0.0/modules/perception/lidar/lib/scene_manager/scene_manager_
算法——贪心算法解0-1背包问题
热门推荐
11-21 1万+
问题的描述我们先根据一个贪心算法的经典应用实例，然后给出贪心算法的实现步骤与关键环节，最后给出C++代码求解0-1背包问题。 背包问题（Knapsack Problem）：有NN件物品有一个承重（也可受限于体积）为CC的背包，每件物品具有二维属性，分别是重量属性wi,i=1,…,Nw_i,\quad i=1,\ldots,N，和价值属性pi,i=1,…,Np_i,\quad i=1,\ldots
我的Effective C++读书笔记
chrispaul3cp的博客
04-03 501
谨作个人记录用，不喜勿喷
Android 9.0 AutoMotive模块之Vehicle
变
06-24 1万+
Vehicle模块简介架构功能流程 简介 借助各种总线拓扑，很多汽车子系统都可以实现互连以及与车载信息娱乐 (IVI) 系统的连接。不同的制造商提供的确切总线类型和协议之间有很大差异（甚至同一品牌的不同车型之间也是如此），例如控制器区域网络 (CAN) 总线、局域互联网络 (LIN) 总线、面向媒体的系统传输 (MOST) 总线以及汽车级以太网和 TCP/IP 网络（如 BroadR-Reach）。Android Automotive 的硬件抽象层 (HAL) 为 Android 框架提供了一致的接口（无需
C++ 容易忽略的特性
wangjieest的专栏
01-02 824
(1)cin----标准输入流对象, 与标准输入设备相联系（通常指键盘）。    例如:  cin>>变量名;    “>>”为提取运算符(输入运算符)，表示从键盘读取数据放入变量中。 (2) cout---标准输出流(流对象), 与标准输出设备相联系（通常指显示器）。     例如: cout “ (3) cerr---非缓冲型的标准出错流对象,与标准输出设备相联系（通常指键盘）。
PAT甲级1001-1030
chstor's blog
11-21 1535
前言：距离四级考试剩31天，PAT甲级考试剩32天 对PAT甲级练习题做总结 1001 A+B Format (20 分) 题目大意：输入一对整数a,b，计算它们的和，输出格式为3个数字一组 题目解析：把a+b的和转换为字符串输出，从后往前看，下标对3取模，当值为0的时候，后面输出逗号，最后一位不用输出逗号 注意：如果为负号或者最后一位，跳过不用输出逗号 英语单词： calculate /ˈkælkjuleɪt/ v. 计算，核算；预测，推测 comma /ˈkɒmə/ n. 逗号；停顿 be s.
C++ 高仿easyX图形库
一个神奇的博客
09-25 1614
C++ 高仿easyX图形库 众所周知，easyX是个很想的东西 不过，easyX目前只支持Visual Studio,这对于初学者十分不利 既然这样，作者大大就干了一件非常非常非常非常非常非常伟大的事情： 把easyX还原到Dev-C++ 上！！！！！ 教程还没准备好… 不过不要紧，作者先上献上代码~~~ //ggcc图形库 //ggcc_graphics.h /*-----------------------------------------------------------------
MyWeibo:仿制的新浪微博
06-10
仿制的新浪微博 功能 使用ASI访问微博接口 简单的换肤功能 发送文字微博功能 下拉刷新最新微博 提示未读微博数量 发送带地理位置的微博 选择地理位置时查询附近的地点 扫描二维码（此功能需要在真机查看） 开发...
MyTmall:个人仿制天猫商城
04-30
MyTmall个人仿制天猫商城项目架构数据量变大后可以采用Mycat对数据库进行分片处理，构成数据库集群开发环境Eclipse OxygenMaven3.3.9MySQL5.7.20virtualbox5.2.4centos6.5软件版本详见tmall-parent的pom.xml项目启动...
Scratch 绘画涂色游戏：仿制绘画
07-23
临摹左边的画！...） 颜色混合供您参考： 橙色：红色+黄色 绿色：蓝色+黄色 紫色：红色+蓝色 角色数量：14，素材数量：69，积木数量：966，音频数量：20 此后仍有作品或有趣游戏、爆笑作品，请关注原作者，且点赞加...
仿制：虚拟操作系统（PRE-ALPHA）
02-04
Faux OS-虚拟网页操作系统 它是什么？ Faux是一个有趣的类Unix操作系统，您可以直接在浏览器中跳入该操作系统。 它通过从各种操作系统中借鉴许多很棒的想法，介绍了一种熟悉的，但是新的计算机使用方式。...
c++ 点到多边形的距离
jacke121的专栏
05-08 290
c++ 点到多边形的距离
C语言中static和volatile关键字的作用
qq_37505962的博客
05-07 174
C语言中关键字 static 与 volatile的作用
UE5C++ FString做为参数取值时报错error：C4840
最新发布
YanisWu的博客
05-11 95
UE5 C++ 的FString类型取值问题。
初识C语言——第十四天
硬件菜鸟的成长之路
05-07 694
【代码】初识C语言——第十四天。
C++11仿制java CountDownTimer
05-23
在C++11中，可以使用std::thread和std::chrono来实现一个类似于Java CountDownTimer的计时器。 下面是一个简单的示例代码： ```c++ #include #include class CountDownTimer { public: CountDownTimer(int ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值