YList 容器适配器：给C++ STL List增加下标

已于 2024-07-14 23:17:18 修改
阅读量154 收藏 3
点赞数 3
分类专栏： QT 技术类型 文章标签： c++ stl list
于 2024-07-14 23:14:19 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_38061001/article/details/140425136
版权

C++ STL list增加下标

c++ list没有下标，利用字典树给c++list增加下标，源码如下，Trie.h中是字典树的相关操作，YList是list的相关操作，main.cpp中是测试接口的代码，没有用unit-test纯粹是因为太懒了，结尾有代码仓库地址，感兴趣的可以去看一下，部分功能还没写完，隔得时间太久了，代码都看不懂了，等后面有空再写吧。

Trie.h

/*
 * 底层使用字典树，字典树中存储key最后一位结点的pValue是list结点的迭代器
*/
#ifndef TRIE_H
#define TRIE_H
#include <vector>
#include <string>
#include <list>
#include <algorithm>
#include <QDebug>
using namespace std;

template <class T>
class Trie
{
public:
    Trie()
        : children(26),isEnd(false),pValue(),l() { }

    explicit
    Trie(const Trie& __x)
        : children(__x.children),
          isEnd(__x.isEnd),
          pValue(__x.pValue),
          l(__x.l) { }

    explicit
    Trie(const Trie&& __x)
        : children(std::move(__x.children)),
          isEnd(std::move(__x.isEnd)),
          pValue(std::move(__x.pValue)),
          l(std::move(__x.l)) { }

    //在字典树中根据key查询value
    bool search(const string& word,T& value)
    {
        if((this->children).size() && (this->l).size())
        {
            Trie<T>* node = this->searchPrefix(word);
            if(node != nullptr && node->isEnd)
            {
                value = *(node->pValue);
                return true;
            }
            return false;
        }
        return false;
    }

    //插入，输入参数为key和list结点的迭代器
    void insert(const string& word,typename list<T>::iterator value)
    {
        Trie<T> *node=this;
        for(int i=0;i<word.size();i++)
        {
            int n = word[i]-'a';
            if(node->children[n]==nullptr)
            {
                node->children[n] = new Trie<T>();
            }
            node = node->children[n];
        }
        node->isEnd = true;
        node->pValue = value;

        //list中存入字典树结点指针（结点中包含迭代器），为了实现通过迭代器删除字典树结点
        l.push_back(node);
    }

    //通过迭代器值删除字典树结点（将pValue置为空），因为l中存储的是字典树结点指针，所以l中删除了，字典树中也相应删除了
    bool deleteItem(typename list<T>::iterator value)
    {
        for(auto it=l.begin();it!=l.end();it++)
        {
            //迭代器加*代表list中的元素，*it是字典树结点指针
            if((*it)->pValue == value)
            {
                (*it)->isEnd = false;
                ((*it)->pValue)._M_node = nullptr;
                return true;
            }
        }
        return false;
    }

    //通过key删除结点
    bool deleteItem(const string& word)
    {
        Trie<T> *cnode=this;
        for(int i=0;i<word.size();i++)
        {
            int n = word[i]-'a';
            if(cnode->children[n]==nullptr)
            {
                return false;
            }
            cnode = cnode->children[n];
        }
        if(cnode->isEnd==false)
        {
            return false;
        }
        else
        {
            cnode->isEnd=false;
            //迭代器的_M_node指向list中该结点，删除时将指针置为空
            (cnode->pValue)._M_node=nullptr;
            return true;
        }
        return false;
    }

    //通过key查询迭代器，迭代器指向list中的结点
    typename list<T>::iterator findIterator(const string& word)
    {
        typename list<T>::iterator tmp;
        Trie<T> *cnode=this;
        //判断vector不为空则进行查找
        if((cnode->children).size() && (cnode->l).size())
        {
            for(int i=0;i<word.size();i++)
            {
                int n = word[i]-'a';
                if(cnode->children[n]==nullptr)
                {
                    return tmp;
                }
                cnode = cnode->children[n];
            }
            return cnode->pValue;
        }
        return tmp;
    }

    //clear
    void clear()
    {
        (this->children).clear();
        (this->l).clear();
        (this->pValue)._M_node=nullptr;
        this->isEnd=false;
    }

    //operator=
    Trie& operator=(const Trie& trie)
    {
        if(this!=&trie)
        {
            this->children = trie.children;
            this->isEnd = trie.isEnd;
            this->pValue = trie.pValue;
            this->l = trie.l;
        }
        return *this;
    }

    //operator==
    inline bool
    operator==(const Trie<T>& __x)
    {
        if(this->children == __x.children &&
                this->isEnd == __x.isEnd &&
                this->pValue == __x.pValue &&
                this->l == __x.l)
        {
            return true;
        }
        return false;
    }

    ~Trie() = default;

private:
    vector<Trie<T>*> children;
    bool isEnd;
    typename list<T>::iterator pValue;
    list<Trie<T>*> l;

    //根据key前缀查询，返回字典树结点指针，查询不到返回空
    Trie<T>* searchPrefix(const string& prefix){
        Trie<T>* node = this;
        for(int i=0;i<prefix.size();i++)
        {
            int n = prefix[i]-'a';
            if(node->children[n]==nullptr)
            {
                return nullptr;
            }
            node = node->children[n];
        }
        return node;
    }
};

#endif // TRIE_H

YList.h

#ifndef YLIST_H
#define YLIST_H
#include "Trie.h"
#include <list>
#include <iostream>

template <typename _Tp>
class YList
{
private:
    typedef list<_Tp> _YList;
    typedef Trie<_Tp> _YTrie;

public:
    //定义value_type等供算法和内部方法使用
    typedef _Tp value_type;
    typedef typename _YList::pointer pointer;
    typedef typename _YList::const_pointer const_pointer;
    typedef typename _YList::reference reference;
    typedef typename _YList::const_reference const_reference;

    //直接用list中的迭代器，迭代器中有
    //difference_type
    //iterator_category
    //value_type
    //pointer
    //reference
    //供算法使用
    typedef typename _YList::iterator iterator;
    typedef typename _YList::const_iterator const_iterator;
    typedef typename _YList::const_reverse_iterator const_reverse_iterator;
    typedef typename _YList::reverse_iterator reverse_iterator;

    typedef typename _YList::size_type size_type;
    typedef typename _YList::difference_type difference_type;
    typedef typename _YList::allocator_type allocator_type;

protected:
    _YList l;
    _YTrie t;

public:
#if __cplusplus < 201103L
    explicit
    YList(const YList& __y = YList())
    : l(__y.l), t(__y.t) { }
#else
    YList()
        : l(), t() { }

    explicit
    YList(const YList& __y)
        : l(__y.l), t(__y.t) { }

    //移动构造函数使用std::move将左值引用转为右值引用
    //移动构造函数消耗小于拷贝构造函数，在拷贝时不再是深拷贝而是浅拷贝
    //原指针将所指对象转移完后置为空，不能再被使用
    explicit
    YList(const YList&& __y)
        : l(std::move(__y.l)), t(std::move(__y.t)) { }
#endif

    //插入key和value
    void
    push_back(const string& word,const value_type& __x)
    {
        l.push_back(__x);
        iterator __tmp = l.end();
        t.insert(word,--(__tmp));
    }

    //通过key删除
    void
    erase(const string& word)
    {
        iterator __tmp = t.findIterator(word);
        if(__tmp._M_node!=nullptr)
        {
            l.erase(__tmp);
            t.deleteItem(word);
        }
    }

    //删除最后一元素
    void
    pop_back()
    {
        //先获取最后一个元素的迭代器，再调用list删除，不然会拿错
        iterator __tmp = l.end();
        //end是最后一个元素后一个迭代器，所以往前走一步
        t.deleteItem(--(__tmp));
        l.pop_back();
    }

    void print()
    {
        for(typename _YList::iterator it = l.begin();it!=l.end();it++)
        {
            std::cout<<*it<<std::endl;
        }
    }

    void print2(const string& word)
    {
        int tmp=0;
        bool res = t.search(word,tmp);
        std::cout<<"res:"<<res<<std::endl;
        std::cout<<"t:"<<tmp<<std::endl;
    }

    //find by key
    template<typename T>
    T
    findByKey(const string& key)
    {
        T res;
        t.search(key,res);
        return res;
    }


    const_iterator
    findIByKey(const string& key) const
    {
        return const_iterator(t.findIterator(key));
    }

    iterator
    findIByKey(const string& key)
    {
        return t.findIterator(key);
    }

    //构造函数，创造n个相同的值

    //构造函数，创造长度为n的list，里面没有值

    YList&
    operator=(const YList& __x)
    {
        if(this!=&__x)
        {
            this->l=__x.l;
            this->t=__x.t;
        }
        return *this;
    }

    //list&
    //operator=(list&& __x)

    //empty
    bool
    empty() const _GLIBCXX_NOEXCEPT
    {
        return l.empty();
    }

    //size
    size_type
    size() const _GLIBCXX_NOEXCEPT
    {
        return *l.end();
    }

    //max_size
    size_type
    max_size() const _GLIBCXX_NOEXCEPT
    {
        return l.max_size();
    }

    //operator ==
    inline bool
    operator==(const YList<_Tp>& __x)
    {
        if(this->l==__x.l && this->t==__x.t)
        {
            return true;
        }
        return false;
    }

    //operator !=
    inline bool
    operator!=(const YList<_Tp>& __x)
    {
        return !(*this == __x);
    }

    iterator
    begin() _GLIBCXX_NOEXCEPT
    {
        iterator it = l.begin();
        return it;
    }

    const_iterator
    begin() const _GLIBCXX_NOEXCEPT
    {
        const_iterator it = l.begin();
        return it;
    }

    iterator
    end() _GLIBCXX_NOEXCEPT
    {
        iterator it = l.end();
        return it;
    }

    const_iterator
    end() const _GLIBCXX_NOEXCEPT
    {
        const_iterator it = l.end();
        return it;
    }

#if __cplusplus >= 201103L

    const_iterator
    cbegin() const _GLIBCXX_NOEXCEPT
    {
        const_iterator it = l.begin();
        return it;
    }

    const_iterator
    cend() const _GLIBCXX_NOEXCEPT
    {
        const_iterator it = l.end();
        return it;
    }

#endif

    reference
    front() _GLIBCXX_NOEXCEPT
    {
        return *begin();
    }

    const_reference
    front() const _GLIBCXX_NOEXCEPT
    {
        return *begin();
    }

    reference
    back() _GLIBCXX_NOEXCEPT
    {
        iterator __tmp = end();
        --__tmp;
        return *__tmp;
    }

    const_reference
    back() const _GLIBCXX_NOEXCEPT
    {
        const_iterator __tmp = end();
        --__tmp;
        return *__tmp;
    }

    //push_front

    //pop_front

    //insert

    //swap

    //clear
    void
    clear() _GLIBCXX_NOEXCEPT
    {
        l.clear();
        t.clear();
    }

    //splice

    //remove

    //operator[]

    //print 打印全部，可以选择是下标还是值

    //erase 通过迭代器删除

    ~YList() = default;
};

#endif // YLIST_H

main

#include <QCoreApplication>
#include <stack>
#include <list>
#include <string>
#include <QDebug>
#include "Trie.h"
#include "YList.h"
using namespace std;
int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);

    stack<int> s;
    list<int> s2;
    list<int>::iterator it;


//    Trie<int> obj;
//    int test=10;
//    int *point=&test;

//    int test2=12;
//    int *point2=&test2;
//    obj.insert("aaa",10);
//    obj.insert("apple",10);
//    obj.insert("bool",12);

//    int output1,output2,output3;
//    bool res1,res2,res3;
//    res1 = obj.search("aaa",output1);
//    res2 = obj.search("apple",output2);
//    res3 = obj.search("bool",output3);
//    qDebug()<<"res1:"<<res1<<"\n output1:"<<output1;
//    qDebug()<<"res2:"<<res2<<"\n output2:"<<output2;
//    qDebug()<<"res3:"<<res3<<"\n output3:"<<output3;

//    int output4=10000;
//    bool res4 = obj.deleteItem("aaa");
//    res1 = obj.search("aaa",output4);
//    qDebug()<<"res4:"<<res4<<"\n res1:"<<res1<<"\n output4:"<<output4;

    //test push_back
    YList<int> *obj = new YList<int>();
    obj->push_back("aaa",2);
    obj->push_back("bbb",4);
    obj->push_back("ccc",6);
    obj->push_back("ddd",7);
    qDebug()<<"list:";
    obj->print();
    obj->print2("aaa");
    obj->print2("bbb");
    obj->print2("ccc");

    //test erase
    qDebug()<<"\n erase";
    obj->erase("bbb");
    obj->print();
    obj->print2("bbb");

    //test pop_back
    qDebug()<<"\n pop_back";
    obj->pop_back();
    obj->print();
    obj->print2("ddd");

    //test findByKey findIByKey
    qDebug()<<"\n find by key";
    int f = obj->findByKey<int>("aaa");
    qDebug()<<"f:"<<f;
//    list<int>::const_iterator it2 = obj->findIByKey("aaa");
    YList<int>::const_iterator it2 = obj->findIByKey("aaa");
    qDebug()<<"it2:"<<*it2;

    f = obj->findByKey<int>("ccc");
    qDebug()<<"f:"<<f;
    it2 = obj->findIByKey("ccc");
//    list<int>::iterator it9 = obj->findIByKey("ccc");
    YList<int>::iterator it9 = obj->findIByKey("ccc");
    qDebug()<<"it2:"<<*it2;
    qDebug()<<"it9:"<<*it9;
    *it9 = 9;
    f = obj->findByKey<int>("ccc");
    qDebug()<<"after it9 f:"<<f;

//    f = obj->findByKey<int>("bbb");
//    qDebug()<<"f:"<<f;
//    it2 = obj->findIByKey("bbb");
//    qDebug()<<"it2:"<<*it2;

    //test empty size max_size
    qDebug()<<"\n size";
    qDebug()<<"empty:"<<obj->empty();
    qDebug()<<"size:"<<obj->size();
    qDebug()<<"max_size:"<<obj->max_size();

    //test operator=
    YList<int> obj2;
    obj2=*obj;
    qDebug()<<"\n size";
    qDebug()<<"empty:"<<obj2.empty();
    qDebug()<<"size:"<<obj2.size();
    qDebug()<<"max_size:"<<obj2.max_size();
    obj2.print();
    obj2.print2("aaa");
    obj2.print2("bbb");
    obj2.print2("ccc");

    //test operator== !=
    qDebug()<<"\n test operator ==";
    if(*obj == obj2)
    {
        qDebug()<<"obj equal obj2";
    }
    else
    {
        qDebug()<<"onj not equal obj2";
    }

    YList<int> obj3;
    if(obj3 == obj2)
    {
        qDebug()<<"obj3 equal obj2";
    }
    else
    {
        qDebug()<<"obj3 not equal obj2";
    }

    if(obj3 != obj2)
    {
        qDebug()<<"obj3 not equal obj2";
    }

    //test clear
    qDebug()<<"\n test clear";
    obj2.clear();
    qDebug()<<"size:"<<obj2.size();
    obj2.print2("aaa");
//    obj->print();
    obj2.print();

    //test end begin front back
    qDebug()<<"\n test end begin front back";
    obj2 = *obj;
    const int test = obj2.front();
    const int test2 = obj2.back();
    qDebug()<<test;
    qDebug()<<test2;
    YList<int>::iterator Itest = obj2.begin();
    YList<int>::const_iterator Itest2 = obj2.begin();
    YList<int>::const_iterator Itest3 = obj2.cbegin();
    qDebug()<<*Itest<<*Itest2<<*Itest3;

    obj2.print();

    YList<int>::iterator Itest4 = obj2.end();
    YList<int>::const_iterator Itest5 = obj2.end();
    YList<int>::const_iterator Itest6 = obj2.cend();
    Itest4--;
    Itest5--;
    Itest6--;
    qDebug()<<*(Itest4)<<*(Itest5)<<*(Itest6);

    return a.exec();
}

Gitee仓库地址：源码地址

卖兔子的小男孩
关注
  • 3
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
4.3Python容器（3）：列表
欧阳桫的技术博客
02-28 917
@列表概述 列表是可编辑的、有序、可重复的元素集 列表中的元素是可以动态增删和修改的 列表的元素通过下标进行访问 @创建列表 普通创建 推导式创建 # 普通创建 mlist = [] # 空列表 mlist = [1, 2.3, "hello", True, 5 + 6j] # 直接赋初值创建 # 推导式创建 mlist = [c for c in "hello"] pri...
第四章：Python容器
xiangchi7的博客
10-05 768
文章目录概述==什么是容器？==第一节：字符串==字符串操作符====字符串长度====比较字符串大小====字符串截取(切片)====判断有无子串==第二节：元组==略====略==第三节：列表==略====略==第四节：集合==略====略==第五节：字典==略====略==第六节：==略====略==第七节：==略====略== 概述 什么是容器？ 容器是用于盛放元素的 由于盛有许多的元素...
消除WXMLRT_$gwx:./yList.wxml:block:10:3: Now you can provide attr `wx:key` for a `wx:for` to improve警告
GrantF的博客
02-02 2880
这个警告的意思是我们在使用wx:for时，也应写上wx:key以提高程序性能。 所以们用key来修正我们前边的字符，或者是在基础上做一个更改修订。 所以我们根据每一个应用场景的不同，来做不同的wx:key的内容。但是要注意，需要我们key中的内容和我们使用的数据名之类的内容是一一对应的。 *this 指向元素本身 ...
List-C++ template
移动互联网改变生活,高效配对交易创造财富
09-01 1093
/**Ylist.h *this is a  list template by array*Ylist ADT list*writer:chinanetboy ,QQ:44633197*blog http://chinanetboy.bokee.com*date:07/01/2008*/#ifndef H_Ylist#define H_Ylist#include #include #include
vs2019中采用C++编程使用python中的matplotlib画图库
酸梅果茶的博客
09-21 2174
在写代码的过程中，有时候需要对数据进行可视化，但是对于C++来说，并没有一个像python中matplotlib一样方便使用且功能强大的绘图包。这里可以采用C++调用python，将matplotlib进行了封装。
python中list_Python List 列表list()方法
weixin_39641876的博客
11-26 222
Python基础数据类型之一列表list，在python中作用很强在，列表List可以包含不同类型的数据对像，同时它是一个有序的变量集合，每个变量可以存储一个地址。所有序列能用到的标准操作方法，列表也都可以使用，比如切片、索引等，python的list是可变数据类型，它支持添加 append、插入 insert、修改、删除del等操作。Python列表list的创建可以把python中的list列...
jpa 传入list_java – Spring Data JPA如何传递日期参数
weixin_33046983的博客
12-24 1158
我正在使用Spring工具套件处理弹簧MVC项目和弹簧数据,我想将日期参数传递给本机查询,到目前为止我已经这样做了.我的查询方法在扩展JpaRepository的接口中@Query(value ="SELECT "+ "a.name, a.lastname+ "FROM "+ "person a, "+ "myTable b "+ "WHERE "+ "a.name= ?1' "+ "AND ...
pythonlist()_Python List 列表list()方法
weixin_39527487的博客
12-18 138
Python基础数据类型之一列表list，在python中作用很强在，列表List可以包含不同类型的数据对像，同时它是一个有序的变量集合，每个变量可以存储一个地址。所有序列能用到的标准操作方法，列表也都可以使用，比如切片、索引等，python的list是可变数据类型，它支持添加 append、插入 insert、修改、删除del等操作。Python列表list的创建可以把python中的list列...
Python报错：TypeError:‘function‘ object is not subscriptable
jinyeran的博客
02-11 1145
function不应使用中括号，而应使用小括号
ylist
02-13
标题“ylist”所指的是一个名为“ylist”的C项目，该项目主要关注于 YunOS 操作系统的相关开发。YunOS 是阿里巴巴集团推出的一款基于 Linux 内核的移动操作系统，旨在提供安全、智能且个性化的用户体验。从描述来看...
y-list:Yjs的列表类型
05-20
清单物件参考创造 var ylist = new Y.List().insert（位置，内容） 在某个位置插入内容.insertContents（位置，内容） 在某个位置插入一组内容。 这期望内容是内容的数组。 .push（内容） 在列表末尾插入内容.delete...
Scala实现冒泡排序、归并排序和快速排序的示例代码
08-25
def merged(xList: List[T], yList: List[T]): List[T] = { (xList, yList) match { case (Nil, _) => yList case (_, Nil) => xList case (x :: xTail, y :: yTail) => { if (less(x, y)) x :: merged(xTail,...
vue实现折线图 可按时间查询
10-14
这些数据应被解析并赋值给`XList`和`YList`，同时更新`YListName`以反映数据集的含义。完成后，调用`myChart.setOption()`来更新图表。 通过以上步骤，我们可以实现一个动态的折线图，它允许用户根据时间范围和统计...
Python从Excel中读取日期一列的方法
09-19
for i in ylist: print(i) ``` 这样，`xlist`包含了日期的年、月、日部分，而`ylist`包含了完整的`datetime`对象。 如果需要计算两个日期之间的差值，可以使用Python的`datetime`库： ```python d1 = datetime....
C语言 之 理解指针（1）
fallzzzzz的博客
07-20 1134
就是先获取该数组的首元素的地址，从前面我们知道，指针的类型的作用是指针+1 所跳过的字节数，int为整形，大小为4个字节，所以p+1就跳过4个字节，p+2就跳过8个字节，计算机的CPU（中央处理器）在处理数据的时候，需要的数据是在内存中读取的，处理后数据也会放回内存中，如果想对这些空间进行高效的管理，就可以。并且我们知道，数组的元素存放是随着下标增长，内存地址变大的。上面的代码创建了一个整型变量n，因为一个整形的大小是4个字节，所以内存中申请了4个字节，⽤于存放整数10，其中每个字节都有地址。
商品信息管理系统(C语言)
zeyeqianli的博客
07-22 330
该案例使用了C语言中最具特色的结构体，将每个商品的所有信息存在结构体中，并且定义一个结构体类型的数组保存所有商品的信息，并且按照模块化的编程思想，将要实现的每个功能编写成独立的函数，这样即方便阅读同时也方便差错修改。该系统的主要功能如下：(1) 登录系统。(2) 创建商品信息。(3) 打印商品信息。(4) 查询商品信息。(5) 修改商品信息。(6) 删除商品信息。(7) 商品价格排名显示。(8) 退出系统。
C++中的模板函数和模板类
2302_81171591的博客
07-22 659
T1 ,classT2 ,... ,classTnclass类模板名//类内成员定义。
内网对抗-隧道技术篇&防火墙组策略&HTTP反向&SSH转发&出网穿透&CrossC2&解决方案
最新发布
siu~
07-24 757
1、C2/C2上线-CrossC2插件-多系统平台支持 2、隧道技术篇-应用层-SSH协议-判断&封装&建立&穿透 3、隧道技术篇-应用层-HTTP协议-判断&封装&建立&穿透
java list分组求和
09-03
在Java中，可以使用Stream的groupingBy和summingLong方法来实现List的分组求和。首先，使用groupingBy方法按照指定的属性进行分组，然后使用summingLong方法对每个分组的元素进行求和。最后，可以通过entrySet方法将...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值