C++实现Vector->类型萃取和List->迭代器

最新推荐文章于 2023-02-25 12:05:37 发布
最新推荐文章于 2023-02-25 12:05:37 发布
阅读量1.3k 收藏 1
点赞数
分类专栏： C++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/quinn0918/article/details/76616998
版权

容器

1.Vector（也可以称之为顺序表）

#include <iostream>
using namespace std;
#include <assert.h>
template <class T>
class Vector
{
public:
    Vector()//构造函数
        :_data(NULL)
        , _size(0)
        , _capa(0)
    {

    }

    ~Vector()//析构函数
    {
        if (_data)
        {
            delete[] _data;
            _data = NULL;
            _size = 0;
            _capa = 0;
        }
    }

    Vector(const Vector<T>& s)//拷贝构造
    {
        _data = new T[s._size];
        for (size_t i = 0; i < s._size; i++)//效率低，但是不会出错
        {
            _data[i] = s._data[i];
        }
        //memcpy(_data, s._data, s._size*sizeof(T));//效率高，但是会出错
        _size = _capa = s._size;
    }

    void Swap(Vector<T>& v)
    {
        std::swap(_data, v._data);
        std::swap(_capa, v._capa);
        std::swap(_size, v._size);
    }

    Vector<T>& operator=(const Vector<T>& s)//赋值运算符“=”重载
    {
        if (this != &s)
        {
            Vector<T> tmp(s);
            Swap(tmp);
        }
        return *this;
    }


    void PushBack(const T& x)//尾插
    {
        CheckCapcacity();
        _data[_size++] = x;
    }

    void PopBack()//尾删
    {
        assert(_size > 0);
        --_size;
    }

    void PushFront(T x)//头插
    {
        CheckCapcacity();
        T end = _size - 1;
        for (size_t i = 0; i < _size; i++)
        {
            _data[end + 1] = _data[end];
            end--;
        }
        _data[0] = x;
        _size++;
    }

    void PopFront()//头删
    {
        for (size_t i = 0; i < _size; i++)
        {
            _data[i] = _data[i + 1];
        }
        _size--;
    }

    void Insert(size_t pos, const T& x)//指定位置插入
    {
        assert(pos < _size);
        CheckCapcacity();
        T end = _size - 1;
        for (size_t i = pos - 1; i < _size; i++)
        {
            _data[end + 1] = _data[end];
            end--;
        }
        _data[pos] = x;
        _size++;
    }

    void Erase(size_t pos)//指定位置删除
    {
        assert(pos < _size);
        for (size_t i = pos; i < _size; i++)
        {
            _data[i] = _data[i + 1];
        }
        _size--;
    }

    void Assign(size_t n, const T& s)//赋n个值为x的元素到vector容器中，
        //这个容器会清除掉vector容器中以前的内容。
    {
        Vector<T> v(s._data);
        Swap(tmp);
    }

    void clear()
    {
        _size = 0;
    }

    T& operator[](size_t pos)//[]重载，可读可写
    {
        assert(pos < _size);
        return _data[pos];
    }

    T& operator[](size_t pos)const//只读
    {
        assert(pos < _size);
        return _data[pos];
    }

    const T& Front()const
    {
        return _data[0];
    }

    const T& Back()const
    {
        return _data[_size - 1];
    }

    size_t Size()const
    {
        return _size;
    }

    size_t Capacity()const
    {
        return _capa;
    }

    bool Empty()const
    {
        return _size == 0;
    }

}

    void CheckCapcacity()
    {
        if (_size == _capa)
        {
            size_t newCapacity = _capa * 2 + 3;
            T* pData = new T[newCapacity];
            //memcpy(pData, _data, sizeof(T)*_size);

            for (size_t idx = 0; idx < _size; ++idx)
            {
                pData[idx] = _data[idx];

            }

            delete[] _data;
            _data = pData;
            _capa = newCapacity;
        }
    }

    void Print()//输出
    {
        for (size_t i = 0; i < _size; ++i)
        {
            cout << _data[i] << " ";
        }
        cout << endl;
    }
private:
    T *_data;
    size_t _size;
    size_t _capa;
};


void Test()
{
    Vector<int> s;
    s.PushBack(1);
    s.PushBack(2);
    s.PushBack(3);
    s.PushBack(4);
    s.Print();
    s.PopBack();
    s.Print();
    s.PushFront(5);
    s.Print();
    s.PopFront();
    s.Print();
    s.Insert(1, 8);
    s.Print();
    s.Erase(1);
    s.Print();
    Vector<int> s1(s);
    s1.Print();
    Vector<int> s2;
    s2 = s1;
    s2.Print();

}

int main()
{
    Test();
    system("pause");
}

2.List（双向带头循环链表）

#include <iostream>
using namespace std;
#include <assert.h>
template<class T>
struct ListNode
{
    ListNode(const T& data = T())
    : _pPre(NULL)
    , _pNext(NULL)
    , _data(data)
    {}

    ListNode<T>* _pPre;
    ListNode<T>* _pNext;
    T            _data;
};

//迭代器
template<class T, class Ref>
class ListIterator
{
    typedef ListIterator<T, Ref> Self;
public:
    ListIterator()
        : _pNode(NULL)
    {}

    ListIterator(ListNode<T>* pNode)
        : _pNode(pNode)
    {}

    Self& operator++()
    {
        _pNode = _pNode->_pNext;
        return *this;
    }

    Self operator++(int)
    {
        Self temp(*this);
        _pNode = _pNode->_pNext;
        return temp;
    }

    Self& operator--()
    {
        _pNode = _pNode->_pPre;
        return *this;
    }

    Self operator--(int)
    {
        Self temp(*this);
        _pNode = _pNode->_pPre;
        return temp;
    }

    bool operator==(const Self& s)
    {
        return _pNode == s._pNode;
    }

    bool operator!=(const Self& s)
    {
        return _pNode != s._pNode;
    }

    Ref operator*()
    {
        return _pNode->_data;
    }

private:
    ListNode<T>* _pNode;
};


void FunTest()
{
    List<int> L;
    L.PushBack(1);
    L.PushBack(2);
    L.PushBack(3);
    L.PushBack(4);

    List<int>::Iterator it = L.Begin();
    while (it != L.End())
    {
        cout << *it << "->";
        ++it;
    }
    cout << endl;

    L.Print();

    L.PushFront(0);
    L.Print();

    L.PopBack();
    L.Print();

    L.PopFront();
    L.Print();

    ListNode<int>* pos = L.Find(2);
    L.Insert(pos, 5);
    L.Print();

    L.Erase(pos);
    L.Print();
}



template<class T>
class List
{
public:
    typedef ListIterator<T, T&> Iterator;
public:
    Iterator Begin()
    {
        return Iterator(_pHead->_pNext);
    }

    Iterator End()
    {
        return Iterator(_pHead);
    }

    List()
    {
        CreateHead();
    }

    List(size_t n, const T& data)
    {
        CreateHead();
        for (size_t idx = 0; idx < n; ++idx)
            PushBack(data);
    }

    ~List()
    {
        Clear();
        delete _pHead;
        _pHead = NULL;
    }

    void PushBack(const T& data)
    {
        ListNode<T>* pTailNode = _pHead->_pPre;
        ListNode<T>* pNewNode = new ListNode<T>(data);
        pTailNode->_pNext = pNewNode;
        pNewNode->_pNext = _pHead;
        pNewNode->_pPre = pTailNode;
        _pHead->_pPre = pNewNode;
    }

    void PopBack()
    {

        if (_pHead == _pHead->_pNext)
        {
            assert(false);
            return;
        }

        ListNode<T>* pTailNode = _pHead->_pPre;
        pTailNode->_pPre->_pNext = _pHead;
        _pHead->_pPre = pTailNode->_pPre;
        delete pTailNode;
    }

    void PushFront(const T& data)
    {
        ListNode<T>* pFirst = _pHead->_pNext;
        ListNode<T>* pNewNode = new ListNode<T>(data);
        pNewNode->_pNext = pFirst;
        pFirst->_pPre = pNewNode;
        pNewNode->_pPre = _pHead;
        _pHead->_pNext = pNewNode;
    }

    void PopFront()
    {
        ListNode<T>* pFirst = _pHead->_pNext;
        _pHead->_pNext = pFirst->_pNext;
        pFirst->_pNext->_pPre = _pHead;
        delete pFirst;
    }

    Iterator Find(const T& data)
    {
        ListNode<T>* pCur = _pHead->_pNext;
        while (pCur != _pHead)
        {
            if (data == pCur->_data)
                return Iterator(pCur);
            pCur = pCur->_pNext;
        }

        return Iterator();
    }

    void Insert(ListNode<T>* pos, const T& data)
    {
        ListNode<T>* pNewNode = new ListNode<T>(data);
        pNewNode->_pNext = pos;
        pos->_pPre->_pNext = pNewNode;
        pNewNode->_pPre = pos->_pPre;
        pos->_pPre = pNewNode;
    }



    void Erase(ListNode<T>* pos)
    {
        pos->_pPre->_pNext = pos->_pNext;
        pos->_pNext->_pPre = pos->_pPre;

        delete pos;
    }

    void Clear()
    {
        ListNode<T>* pCur = _pHead->_pNext;
        ListNode<T>* pPre = NULL;
        while (pCur != _pHead)
        {
            pPre = pCur;
            pCur = pCur->_pNext;
            delete pPre;
        }

        _pHead->_pNext = _pHead;
        _pHead->_pPre = _pHead;
    }


    bool Empty()const
    {
        return _pHead->_pNext == _pHead;
    }

    size_t Size()const
    {
        size_t count = 0;
        ListNode<T>* pCur = _pHead->_pNext;
        while (pCur != _pHead)
        {
            count++;
            pCur = pCur->_pNext;
        }

        return count;
    }

    void Print()
    {
        ListNode<T>* pCur = _pHead->_pNext;
        while (pCur != _pHead)
        {
            cout << pCur->_data << "->";
            pCur = pCur->_pNext;
        }
        cout << "NULL" << endl;
    }

private:
    void CreateHead()
    {
        _pHead = new ListNode<T>;
        _pHead->_pNext = _pHead;
        _pHead->_pPre = _pHead;
    }
private:
    ListNode<T>* _pHead;
};

模板类的全特化和偏特化


template<class T>
class Vector
{
public:
    Vector()
    {
        cout<<typeid(T).name()<<endl;
    }
private:
    T* _pData;
    size_t _size;
    size_t _capacity;
};

// 全特化
template<>
class Vector<int>
{
public:
    Vector<int>()
    {
        cout<<"int"<<endl;
    }
private:
    int* _pData;
    size_t _size;
    size_t _capacity;
};

// 偏特化: 
template<class T>
class Vector<T*>
{
public:
    Vector()
    {
        cout<<typeid(T).name()<<"*"<<endl;
    }
};
//偏特化
template<class T>
class Vector<T&>
{
public:
    Vector()
    {
        cout<<typeid(T).name()<<"&"<<endl;
    }
};


int main()
{
    Vector<char> v1;
    Vector<int> v2;
    Vector<int*> v3;
    Vector<char*> v4;
    Vector<int&> v5;
    return 0;
}

类型萃取

// 内置类型
struct _TrueType_
{
    static bool Get()
    {
        return true;
    }
};

// 自定义类型
struct _FalseType_
{
    static bool Get()
    {
        return false;
    }
};

// 模板类的特化-->任意类型
template<class T>
struct TypeTraits
{
    typedef _FalseType_ IsPOD; // plain old type--->内置类型
};

// 特化
template<>
struct TypeTraits<int>
{
    typedef _TrueType_ IsPOD;
};

template<>
struct TypeTraits<char>
{
    typedef _TrueType_ IsPOD;
};


template<class T>
void _Copy(T* dst, T* src, size_t n, _FalseType_)
{
    for (size_t idx = 0; idx < n; ++idx)
    {
        dst[idx] = src[idx];
    }
}

template<class T>
void _Copy(T* dst, T* src, size_t n, _TrueType_)
{
    memcpy(dst, src, sizeof(T)*n);
}


template<class T>
void Copy(T* dst, T* src, size_t n)
{
    _Copy(dst, src, n, TypeTraits<T>::IsPOD());
}

#include <string>

void TestCopy()
{
    int array1[] = {1,2,3,4,5,6,7,8,9};
    int array2[sizeof(array1)/sizeof(array1[0])];

    // 内置类型
    Copy(array2, array1, sizeof(array1)/sizeof(array1[0]));

    string s1[] = {"1111", "2222", "3333", "4444"};
    string s2[sizeof(s1)/sizeof(s1[0])];
    Copy(s2, s1, sizeof(s1)/sizeof(s1[0]));
}

int main()
{
    TestCopy();
    return 0;
}
Quinn0918
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
c++设计模式-行为型模式-迭代器模式
06-25
c++设计模式-行为型模式-迭代器模式；qt工程；c++简单源码；迭代器（Iterator）模式的定义：提供一个对象来顺序访问聚合对象中的一系列数据，而不暴露聚合对象的内部表示。
C++之迭代器(Iterator)模式
lovely_yoshino的博客
06-20 5588
0. 简介 迭代器模式是一种行为设计模式， 它可以有效管理数据流动的同时，让用户能在不暴露集合底层表现形式 （列表、 栈和树等） 的情况下遍历集合中所有的元素。 迭代器通常会提供一个获取集合元素的基本方法。 客户端可不断调用该方法直至它不返回任何内容， 这意味着迭代器已经遍历了所有元素。 1. 迭代器模式示意图 迭代器模式的使用方法和c11的迭代器使用方法类似，这是我们会根据我们的需求去建立迭代器模型。 抽象容器（Collection）：一般是一个接口，提供一个iterator()方法，例如Collect
C++设计模式(20)——迭代器模式
伍粟的博客
02-25 1221
C++ 迭代器模式
【C++】类型萃取实现迭代器操作
xiaoxiaoguailou的博客
03-12 727
文章目录一、关于迭代器操作二、关于迭代器三、实现advance四、实现distance 一、关于迭代器操作 这里主要实现这两个函数的具体实现原理：类型萃取实现函数重载，从而达到不同类型容器中的迭代器都可以进行使用该函数advance和distance函数。并且不同的迭代器类型可以使用不同的方法，从而提高效率（例如随机迭代器正向移动5下，可以使用循环，也直接可以 += 5，很明显随机迭代器使用后者效率将O(n)提到了O(1)）。 二、关于迭代器 迭代器按照功能可分为五类：输入迭代器、输出迭代器、向前迭
C++STL类型萃取与迭代器的深入探究
Jiangtagong的博客
05-17 524
C++的类型萃取技术 自从C++中引入了template后，以泛型技术为中心的设计得到了长足的进步。STL就是这个阶段杰出的产物。STL的目标就是要把数据和算法分开，分别对其进行设计，之后通过一种名为iterator的东西，把这二者再粘接到一起。设计模式中，关于iterator的描述为：一种能够顺序访问容器中每个元素的方法，使用该方法不能暴露容器内部的表达方式。可以说，类型萃取技术就是为了要解决和iterator有关的问题的，下面，我们就来看看整个故事。 应该说，迭代器就是一种智能指针，因此，它也就拥
C++模板编程之类型萃取 惊鸿一瞥
qq_43148810的博客
08-17 430
http://11142019.bog.51cto.com/11132019/1846832
c++中Stringstream的用法: int->string string->int 实现数据类型的转变
09-18
string->int时只要遇到字母字符串就停止输入
C++ 模拟实现list(迭代器)实现代码
01-01
C++ 模拟实现list(迭代器) 实现代码： #pragma once; #include <assert> #include<iostream> #include <assert> using namespace std; template<class> struct __ListNode { T _data; __ListNode<T>* _next; __...
C++ vector----臭飯飯_C++_vector_
10-03
vector类中所有函数介绍，所有的操作基本上都有
C++设计模式-迭代器模式
IT1995的博客
08-02 4743
目录 基本概念 代码与实例 基本概念 迭代器模式（Iterator）：提供一种方法顺序访问一个聚合对象中各个元素，而又不暴露该对象的内部表示。 当你需要一个聚集对象，而且不管这些对象，而不管这些对象是什么都需要遍历的时候，就应该考虑用迭代器模式； 当需要对聚集有多种方式遍历的时候，可以考虑用迭代器模式。 UML图如下（此图来源于大话设计模式） 代码与实例...
迭代器模式（Iterator）C++实现
03-14
迭代器模式（Iterator）C++实现
C++ STL学习笔记——traits萃取器篇
weixin_42561936的博客
01-13 144
【代码】C++ STL学习笔记——traits萃取器篇。
类型萃取实现vector
Anger_Ant的博客
06-26 453
C++中通过类型萃取来实现对象类型的识别。 类型萃取的实际用例：1.SeqList 2.统一内存管理 3.STL POD:plain old data平凡类型--基本类型，值C++中与C兼容的类型，可以按照C的方式处理 POD类型萃取如下： #pragma once struct _TrueType {}; struct _FlaseType {}; template str
C++迭代器
热门推荐
weixin_41368411的博客
04-18 1万+
什么是迭代器： C++中，迭代器就是一个类似于指针的对象，它能够用来遍历C++标准模板库容器中的部分或全部元素，每个迭代器对象代表容器中的确定的地址。以下面的string为例子介绍说明。 对string 对象s1正向遍历输出，代码如下所示： string::iterator it = s.begin(); //此处的begin()函数有两个重载函数，分别是 //iterator begin(); //const_iterator begin() const; //调用他们的对象，分别是可以
C++ 迭代器萃取
XXXTENTAC1ON的博客
04-22 373
迭代器萃取迭代器型别迭代器类型迭代器萃取 迭代器型别 value type 值类型，是指迭代器所知物件的型别 difference type 相差型别，表示两个迭代器之间的距离 reference type 引用类型，从迭代器所指之物的内容是否允许改变 pointer type 指针类型，迭代器所指之物的地址 iterator_category 迭代器的相应型别 迭代器类型 Input Iterator 只读迭代器 Output Iterator 可写迭代器 Forward Iterator 正
C++ STL标准模板库-优秀的C++标准库
08-23
STL是Standard Template Library的简称，中文名标准模板库，是由Alexander Stepanov、Meng Lee和David R Musser在惠普实验室开发的 ，是一个具有工业强度的，高效的C++库，STL早已是ANSI/ISO C++标准中的一部分。STL库由于其对跨平台，对标准C++的支持，开源，高效等优点，如今已经被广泛运用于企业级开发。
【c++】简单实现vector中的迭代器
zDavid_2018的博客
07-27 2414
零、前言 最近几天，真的是和迭代器干上了....... 这篇博客，通过简单实现vector中的迭代器，了解迭代器的机制 一、迭代器的设计思想： 为什么要有迭代器？ 答：迭代器模式（Iterator ）：提供一种方法顺序访问聚合对象中的每个元素，而不是暴露其内部表示。 要访问容器对象就要涉及要遍历算法，我们可以将遍历算法封装在容器中，但是这样的话容器类就承担了太多的功能，容器不仅要维护自...
197-C++运算符的重载（vector容器的迭代器iterator实现）
Edward_LF的博客
05-12 2103
1、初步在自定义vector类中实现迭代器 1.1、迭代器定义 迭代器示意图： 为什么迭代器遍历所有容器方式都是一样？ 因为迭代器遍历完当前元素跳到下一个元素，底层数据结构的具体的遍历方式都封装在这个迭代器的++运算符函数了； 所以，作为使用方，我们不需要知道底层的数据结构原理； 我们只知道底层数据元素的遍历都封装在++运算符重载函数里面。 1.2、自定义vector类中 实现迭代器 在之前实现的vector基础上，继续完善！ 1、‘[]’ 重载函数 2、迭代器初步实现 迭代器一般实现成容器的嵌套
C++设计模式 迭代器模式
406156440的博客
10-05 2190
文章目录1. 理论基础2. 逻辑代码3. 应用 1. 理论基础 2. 逻辑代码 template<class T> class Iterator; template<class T> class ConcreteIterator; template<class T> class Aggregate; template<class T> class ConcreteAggregate; // 聚集抽象类 template<class T&gt
怎么使用 vector<int> 类型的迭代器
最新发布
05-31
使用 vector<int> 类型的迭代器可以通过以下方式： 1. 定义迭代器变量 ```c++ vector<int> v {1, 2, 3, 4, 5}; vector<int>::iterator it; // 定义迭代器变量 ``` 2. 遍历 vector ```c++ vector<int> v {1, 2, 3...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值