STL之list容器的介绍与模拟实现+适配器

最新推荐文章于 2024-05-20 15:29:54 发布
最新推荐文章于 2024-05-20 15:29:54 发布
阅读量1.6k 收藏 34
点赞数 28
分类专栏： # C“嘎嘎” 系统学习 文章标签： c++ list 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_74276498/article/details/136004676
版权

STL之list容器的介绍与模拟实现+适配器

所属专栏：C“嘎嘎" 系统学习❤️
🚀 >博主首页：初阳785❤️
🚀 >代码托管：chuyang785❤️
🚀 >感谢大家的支持，您的点赞和关注是对我最大的支持！！！❤️
🚀 >博主也会更加的努力，创作出更优质的博文！！❤️

1. list的介绍

list的文档介绍

  1. list是可以在常数范围内在任意位置进行插入和删除的序列式容器，并且该容器可以前后双向迭代。
  2. list的底层是双向链表结构，双向链表中每个元素存储在互不相关的独立节点中，在节点中通过指针指向
    其前一个元素和后一个元素。
  3. list与forward_list非常相似：最主要的不同在于forward_list是单链表，只能朝前迭代，已让其更简单高效。
  4. 与其他的序列式容器相比(array，vector，deque)，list通常在任意位置进行插入、移除元素的执行效率更好。
  5. 与其他序列式容器相比，list和forward_list最大的缺陷是不支持任意位置的随机访问，比如：要访问list
    的第6个元素，必须从已知的位置(比如头部或者尾部)迭代到该位置，在这段位置上迭代需要线性的时间
    开销；list还需要一些额外的空间，以保存每个节点的相关联信息(对于存储类型较小元素的大list来说这
    可能是一个重要的因素)

2. list容器的使用

2.1 list的定义

构造函数（ (constructor)）接口说明
list (size_type n, const value_type& val = value_type())构造的list中包含n个值为val的元素
list()构造空的list
list (const list& x)拷贝构造函数
list (InputIterator first, InputIterator last)用[first, last)区间中的元素构造list

2.2 list iterator的使用

函数声明接口说明
begin +end返回第一个元素的迭代器+返回最后一个元素下一个位置的迭代器
rbegin +rend返回第一个元素的reverse_iterator,即end位置，返回最后一个元素下一个位置的reverse_iterator,即begin位置

【注意】

  1. begin与end为正向迭代器，对迭代器执行++操作，迭代器向后移动
  2. rbegin(end)与rend(begin)为反向迭代器，对迭代器执行++操作，迭代器向前移动

2.3 list capacity

函数声明接口说明
empty检测list是否为空，是返回true，否则返回false
size返回list中有效节点的个数

2.4 list element access

函数声明接口说明
front返回list的第一个节点中值的引用
back返回list的最后一个节点中值的引用

2.5 list modifiers

函数声明接口说明
push_front在list首元素前插入值为val的元素
pop_front删除list中第一个元素
push_back在list尾部插入值为val的元素
pop_back删除list中最后一个元素
insert在list position 位置中插入值为val的元素
erase删除list position位置的元素
swap交换两个list中的元素
clear清空list中的有效元素

2.6 list的迭代器失效

前面说过，此处大家可将迭代器暂时理解成类似于指针，迭代器失效即迭代器所指向的节点的无效，即该节
点被删除了。因为list的底层结构为带头结点的双向循环链表，因此在list中进行插入时是不会导致list的迭代
器失效的，只有在删除时才会失效，并且失效的只是指向被删除节点的迭代器，其他迭代器不会受到影响。

void TestListIterator1()
{
	int array[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 0 };
	list<int> l(array, array+sizeof(array)/sizeof(array[0]));
	auto it = l.begin();
	while (it != l.end())
	{
		// erase()函数执行后，it所指向的节点已被删除，因此it无效，在下一次使用it时，必须先给
		其赋值
		l.erase(it);
		++it;
	}
}

// 改正
void TestListIterator()
{
	int array[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 0 };
	list<int> l(array, array+sizeof(array)/sizeof(array[0]));
	auto it = l.begin();
	while (it != l.end())
	{
		it = l.erase(it);
	}
}

3. list的模拟实现

3.1 架构搭建

  • 首先，list容器的底层实现是一个双向循环链表。所以在实现本章节的前提下，我们首先要熟知我们学习C语言的时候是怎么实现一个带头双向循环链表的。核心的逻辑思维是一模一样的。
  • 所以在实现的前提下，我们可以先从C语言数据结构着手起步。
  • 整体的构架就是：1. 要有一个节点的类，里面包含了两个指针next和prev，和一个存放数据的变量val。2. 就是构建list类，在类里面进行一些类的操作。
  template<class T>
  struct ListNode
  {
      ListNode(const T& val = T())
          :_pPre(nullptr)
          ,_pNext(nullptr)
          ,_val(val)
      {}

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

  //list类
  template<class T>
  class list
  {
      typedef ListNode<T> Node;
      //typedef Node* PNode;
  public:
      //正向迭代器
      typedef ListIterator<T, T&, T*> iterator;
      typedef ListIterator<T, const T&, const T*> const_iterator;

      //反向迭代器
      typedef Reverse_iterator<iterator, T&, T*> reverse_iterator;
      typedef Reverse_iterator<const_iterator, const T&, const T*> const_reverse_iterator;

  public:
      ///
      // List的构造
      list()
      {……}

      //拷贝构造
      list(const list<T>& l)
      {……}
      
      ~list()
      {……}
//………………
  private:
  	//创建新节点
      void CreateHead()
      {
          _pHead = new Node;
          _pHead->_pPre = _pHead;
          _pHead->_pNext = _pHead;
      }
      Node* _pHead;
}

3.2 迭代器

同样提供两个版本const 和 非const版本的。

  • 但是这里要注意一点就是，我们的迭代器在进行移动的时候无非就是++/–操作，但是我们可由直接进行（iterator）a++吗？如果这是个内置类型的话那自然是可以的。但是组成list容器并非是内置类型，而是自定义类型，每个节点都是一个类，而自定义类型是无法直接进行++/–等一些类的运算符操作的。要想对自定义类型进行运算符操作就必须要使用运算符重载函数。所以为了可以对迭代器进行运算符操作就也要定义一个迭代器类，并在类中包含要进行操作的自定义类型的对象，在类中进行运算符操作。

3.2.1 正向迭代器

template<class T, class Ref, class Ptr>
class ListIterator
{
public:
    typedef ListNode<T> PNode;
    typedef ListIterator<T, Ref, Ptr> Self; 

    PNode* _pNode;

    ListIterator(PNode* pNode = nullptr)
        :_pNode(pNode)
    {}

    //ListIterator(const Self& l);
    Ref operator*()
    {
        return _pNode->_val;
    }

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

    Self operator++(int)
    {
        Self tmp(*this);//拷贝构造（浅拷贝）
        _pNode = _pNode->_pNext;
        return tmp;
    }
    Self& operator--()
    {
        _pNode = _pNode->_pPre;
        return *this;
    }
    Self& operator--(int)
    {
        Self tmp(*this);
        _pNode = _pNode->_pPre;
        return tmp;
    }
    bool operator!=(const Self& l)
    {
        return _pNode != l._pNode;
    }
    bool operator==(const Self& l)
    {
        return _pNode == l._pNode;
    }
};
  • 注：这里我们可以看到我们创建ListIterator类的时候使用了类模板，并且看到模板参数中不止一个参数，而是多了两个Ref和Ptr。至于理由是：我们要实现两个版本的迭代器，一个是const和非const版本的，而这两个版本的区别无非就是返回的引用值是否能被修改该，也就是重载*解引用的时候，const版本返回的是const T&，非const版本返回的就是T&，除了这个其他的地方都一样。那如果想两个都实现是不是就要copy一份呢？一下写两个出来呢？所以这个时候模板参数起作用了。定义Ref模板参数，不管是T&还是const T&我们都返回Ref只是当我们想调用const版本的时候就给模板传const T&的类型，我们想调用非cosnt版本的时候就传T&类型的给模板就行，这样就可以避免代码重复问题，提高复用度。
  • 同样的既然我们定义是一个自定义类型的节点，迭代器可以看作是一个指针，有了自定义类型和之指针我们就可以通过指针+ (->)的方式拿到节点里面的val值，但是->同样也有两个版本，所以做法和上面的是一样的，只需要多个模板参数传一个值Ptr就行，具体调用什么版本的就传什么类型的过去就行。
  • 这里同样也要注意的一点就是重载(->)的时候，我们是这样定义的：
    Ptr operator->() { return &_pNode->_val; }
    本来我们使用的时候应该it->->val这样有两个箭头使用，也就是it.operator->()->val这样去使用的，但是编译为了方便使用做了优化只需要一个箭头就可进行访问了。

3.2.2反向迭代器+适配器

适配器:
适配器是一种设计模式(设计模式是一套被反复使用的、多数人知晓的、经过分类编目的、代码设计经验的总
结)，该种模式是将一个类的接口转换成客户希望的另外一个接口
在这里插入图片描述
用简单话来概括适配器就是——用现有的东西适配出一个新的东西。

我们的反向迭代器其实就是用到了适配器的概念，用到就是正向迭代器适配出来的。
在这里插入图片描述

  • rbegin的++就是end的–，rend的–就是begin的++，要取rbegin指向的值就是–end()在解引用得到。
    所以我们只需要讲正向迭代器的类型当作参数传个我们的反向迭代器的类模板参数就行。
  • 同样的这里也需要传三个模板参数，原理和上面是一样的。
template<class Iterator, class Pef, class Ptr>
struct Reverse_iterator
{
	typedef Reverse_iterator<Iterator, Pef, Ptr> self;

	Iterator cur;

	Reverse_iterator(Iterator it)
		:cur(it)
	{}

	Ptr operator->()
	{
		return &(operator*());
	}

	self& operator++()
	{
		--cur;
		return *this;
	}

	self operator++(int)
	{
		Iterator tmp = cur;
		--cur;
		return tmp;
	}

	self& operator--()
	{
		++cur;
		return *this;
	}

	self operator--(int)
	{
		Iterator tmp = cur;
		++cur;
		return tmp;
	}

	Pef operator*()
	{
		Iterator tmp = cur;
		--tmp;
		return *tmp;
	}

	bool operator!=(const self& l)
	{
		return cur != l.cur;
	}

	bool operator==(const self& l)
	{
		return cur == l.cur;
	}
};

3.3 空间控制模块

  1. 返回list容器的大小
size_t size() const
{
    size_t len = 0;
    const_iterator it = begin();//这里要用const_iterator迭代器，this被const修饰了
    while (it != end())
    {
        ++len;
        ++it;
    }
    return len;
}
  1. list容器是否为空
bool empty()const
{
    return begin() == end();
}
  1. resize
void resize(size_t newsize, const T& data = T())
{
	size_t oldsize = size();
	if (newsize <= oldsize)
	{
		// 有效元素个数减少到newsize
		while (newsize < oldsize)
		{
			pop_back();
			oldsize--;
		}
	}
	else
	{
		while (oldsize < newsize)
		{
			push_back(data);
			oldsize++;
		}
	}
}

3.4 数据的访问

  1. 访问头节点的值
T& front()
{
    return (begin()._pNode)->_pNext->_val;
}
const T& front()const
{
    return (begin()._pNode)->_pNext->_val;

}
  1. 访问尾节点的值
T& back()
{
    return (end()._pNode)->_pPre->_val;
}
const T& back()const
{
    return (end()._pNode)->_pPre->_val;
}

3.5 增加/删除数据

  1. 在pos位置前插入值为val的节点
iterator insert(iterator pos, const T& val)
{
    Node* newnode = new Node;
    newnode->_val = val;
    Node* cur = pos._pNode;
    Node* prev = cur->_pPre;

    prev->_pNext = newnode;
    newnode->_pPre = prev;
    newnode->_pNext = cur;
    cur->_pPre = newnode;

    return iterator(newnode);
}
  1. 删除pos位置的节点，返回该节点的下一个位置
iterator erase(iterator pos)
        {
            Node* cur = pos._pNode;
            Node* prev = cur->_pPre;
            Node* next = cur->_pNext;

            prev->_pNext = next;
            next->_pPre = prev;

            return iterator(next);
        }
  1. push_back/pop_back
void push_back(const T& val) 
{
    insert(end(), val); 
}
void pop_back() 
{ 
    erase(--end()); 
}
  1. push_front/pop_front
void push_front(const T& val) 
{ 
    insert(begin(), val); 
}
void pop_front() 
{ 
    erase(begin()); 
}
  1. 清除数据
void clear()
{
    iterator it = begin();
    while (it != end())
    {
        it = erase(it);
    }
}

3.6 构造/拷贝构造/析构

  1. 构造函数
list()
{
    CreateHead();
}

list(int n, const T& value = T())
{
    CreateHead();//先创建哨兵位
    for (int i = 0; i < n; i++)
    {
        push_back(value);
    }
}


template <class Iterator>
list(Iterator first, Iterator last)
{
    CreateHead();//先创建哨兵位
    while (first != last)
    {
        push_back(*first);
        ++first;
    }
}
  1. 拷贝构造
list(const list<T>& l)
{
    CreateHead();//先创建哨兵位
    const_iterator it = l.begin();
    while (it != l.end())
    {
        push_back(*it);
        ++it;
    }
}
  1. 赋值运算符重载
void swap(list<T>& l)
{
    std::swap(_pHead, l._pHead);
}

list<T>& operator=(list<T> l) 
{
    swap(l);
    return *this;
}
  1. 析构
~list()
{
    //iterator it = begin();
    //while (it != end())
    //{
    //    Node* cur = it._pNode;
    //    _pHead->_pNext = cur->_pNext;
    //    delete cur;
    //}

    clear();
    delete _pHead;
    _pHead = nullptr;
}

4. 整体代码逻辑

namespace qfw
{
    // List的节点类
    template<class T>
    struct ListNode
    {
        ListNode(const T& val = T())
            :_pPre(nullptr)
            ,_pNext(nullptr)
            ,_val(val)
        {}

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


    //List的迭代器类
    template<class T, class Ref, class Ptr>
    class ListIterator
    {
    public:
        typedef ListNode<T> PNode;
        typedef ListIterator<T, Ref, Ptr> Self; 

        PNode* _pNode;

        ListIterator(PNode* pNode = nullptr)
            :_pNode(pNode)
        {}

        //ListIterator(const Self& l);
        Ref operator*()
        {
            return _pNode->_val;
        }

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

        Self operator++(int)
        {
            Self tmp(*this);//拷贝构造（浅拷贝）
            _pNode = _pNode->_pNext;
            return tmp;
        }
        Self& operator--()
        {
            _pNode = _pNode->_pPre;
            return *this;
        }
        Self& operator--(int)
        {
            Self tmp(*this);
            _pNode = _pNode->_pPre;
            return tmp;
        }
        bool operator!=(const Self& l)
        {
            return _pNode != l._pNode;
        }
        bool operator==(const Self& l)
        {
            return _pNode == l._pNode;
        }
    };

	template<class Iterator, class Pef, class Ptr>
	struct Reverse_iterator
	{
		typedef Reverse_iterator<Iterator, Pef, Ptr> self;
	
		Iterator cur;
	
		Reverse_iterator(Iterator it)
			:cur(it)
		{}
	
		Ptr operator->()
		{
			return &(operator*());
		}
	
		self& operator++()
		{
			--cur;
			return *this;
		}
	
		self operator++(int)
		{
			Iterator tmp = cur;
			--cur;
			return tmp;
		}
	
		self& operator--()
		{
			++cur;
			return *this;
		}
	
		self operator--(int)
		{
			Iterator tmp = cur;
			++cur;
			return tmp;
		}
	
		Pef operator*()
		{
			Iterator tmp = cur;
			--tmp;
			return *tmp;
		}
	
		bool operator!=(const self& l)
		{
			return cur != l.cur;
		}
	
		bool operator==(const self& l)
		{
			return cur == l.cur;
		}
	};

    //list类
    template<class T>
    class list
    {
        typedef ListNode<T> Node;
        //typedef Node* PNode;
    public:
        //正向迭代器
        typedef ListIterator<T, T&, T*> iterator;
        typedef ListIterator<T, const T&, const T*> const_iterator;

        //反向迭代器
        typedef Reverse_iterator<iterator, T&, T*> reverse_iterator;
        typedef Reverse_iterator<const_iterator, const T&, const T*> const_reverse_iterator;

    public:
        ///
        // List的构造
        list()
        {
            CreateHead();
        }

        list(int n, const T& value = T())
        {
            CreateHead();//先创建哨兵位
            for (int i = 0; i < n; i++)
            {
                push_back(value);
            }
        }

        template <class Iterator>
        list(Iterator first, Iterator last)
        {
            CreateHead();//先创建哨兵位
            while (first != last)
            {
                push_back(*first);
                ++first;
            }
        }

        //拷贝构造
        list(const list<T>& l)
        {
            CreateHead();//先创建哨兵位
            const_iterator it = l.begin();
            while (it != l.end())
            {
                push_back(*it);
                ++it;
            }
        }

        void swap(list<T>& l)
        {
            std::swap(_pHead, l._pHead);
        }

        list<T>& operator=(list<T> l) 
        {
            swap(l);
            return *this;
        }
        ~list()
        {
            //iterator it = begin();
            //while (it != end())
            //{
            //    Node* cur = it._pNode;
            //    _pHead->_pNext = cur->_pNext;
            //    delete cur;
            //}

            clear();
            delete _pHead;
            _pHead = nullptr;
        }


        ///
        // List Iterator
        iterator begin()
        {
            return iterator(_pHead->_pNext);
        }
        iterator end()
        {
            return iterator(_pHead);
        }
        const_iterator begin() const
        {
            return const_iterator(_pHead->_pNext);
        }
        const_iterator end() const
        {
            return const_iterator(_pHead);
        }

        reverse_iterator rbegin()
        {
            return reverse_iterator(end());
        }

        reverse_iterator rend()
        {
            return reverse_iterator(begin());
        }

        const_reverse_iterator rbegin() const
        {
            return const_reverse_iterator(end());
        }

        const_reverse_iterator rend() const
        {
            return const_reverse_iterator(begin());
        }

        ///
        // List Capacity
        size_t size() const
        {
            size_t len = 0;
            const_iterator it = begin();//这里要用const_iterator迭代器，this被const修饰了
            while (it != end())
            {
                ++len;
                ++it;
            }
            return len;
        }
        bool empty()const
        {
            return begin() == end();
        }

        void resize(size_t newsize, const T& data = T())
        {
            size_t oldsize = size();
            if (newsize <= oldsize)
            {
                // 有效元素个数减少到newsize
                while (newsize < oldsize)
                {
                    pop_back();
                    oldsize--;
                }
            }
            else
            {
                while (oldsize < newsize)
                {
                    push_back(data);
                    oldsize++;
                }
            }
        }

        
        // List Access
        T& front()
        {
            return (begin()._pNode)->_pNext->_val;
        }
        const T& front()const
        {
            return (begin()._pNode)->_pNext->_val;

        }
        T& back()
        {
            return (end()._pNode)->_pPre->_val;
        }
        const T& back()const
        {
            return (end()._pNode)->_pPre->_val;
        }


        
        // List Modify
        void push_back(const T& val) 
        {
            insert(end(), val); 
        }
        void pop_back() 
        { 
            erase(--end()); 
        }
        void push_front(const T& val) 
        { 
            insert(begin(), val); 
        }
        void pop_front() 
        { 
            erase(begin()); 
        }
        // 在pos位置前插入值为val的节点
        iterator insert(iterator pos, const T& val)
        {
            Node* newnode = new Node;
            newnode->_val = val;
            Node* cur = pos._pNode;
            Node* prev = cur->_pPre;

            prev->_pNext = newnode;
            newnode->_pPre = prev;
            newnode->_pNext = cur;
            cur->_pPre = newnode;

            return iterator(newnode);
        }
        // 删除pos位置的节点，返回该节点的下一个位置
        iterator erase(iterator pos)
        {
            Node* cur = pos._pNode;
            Node* prev = cur->_pPre;
            Node* next = cur->_pNext;

            prev->_pNext = next;
            next->_pPre = prev;

            return iterator(next);
        }
        void clear()
        {
            iterator it = begin();
            while (it != end())
            {
                it = erase(it);
            }
        }
    private:
        void CreateHead()
        {
            _pHead = new Node;
            _pHead->_pPre = _pHead;
            _pHead->_pNext = _pHead;
        }
        Node* _pHead;
    };
初阳hacker
关注
  • 28
    点赞
  • 踩
  • 34
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 7
    评论
专栏目录
c++ STL容器总结之:vertor与list的应用
09-05
本篇文章对c++中STL容器中的vertor与list的应用进行了详细的分析解释。需要的朋友参考下
关于STL中list容器的一些总结
12-26
list的实现大概是这样的：list的每个节点有三个域：前驱元素指针域、数据域和后继元素指针域。前驱元素指针域保存了前驱元素的首地址；数据域则是本节点的数据；后继元素指针域则保存了后继元素的首地址。其实，list...
C++ STL学习之【容器适配器】
北 海的博客
04-21 4718
适配器（配接器）是STL中的六大组件之一，扮演着轴承、转换器的角色，使得STL中组件的使用更为灵活，比如栈和队列就是属于适配器而非容器，以及神秘的反向迭代器也属于适配器
【STL十二】适配器——容器适配器
junxuezheng的博客
04-19 937
适配器种类：容器适配器、迭代器适配器、函数适配器
STL设计之容器适配器,加之经典题目解析
小杰312的博客
03-31 2563
STL设计之queue,stack,priority_queue
【C++】模拟实现STL容器：list
学了就忘是正常现象
12-06 1539
list的普通迭代器通过类进行封装+运算符重载实现。 list的const通过类模板实现。 operator*返回节点的数据。 operator->返回节点数据的指针。
C++ STL - list 模拟实现+解析迭代器
TPON的博客
10-12 892
STL - list iterator const_iterator reverse_iterator 模拟实现
【C++】STL容器：list的模拟实现
ermu的博客
01-14 5187
STL容器：list的模拟实现
STL之stack等容器适配器
玄鸟轩墨的博客
08-24 314
反向迭代器 容器适配器 STL　stack　栈　queue 堆 队列
【STL】容器 - list的模拟实现
Hello_World_213的博客
10-03 788
list模拟实现, list迭代器详解, 反向迭代器(迭代器适配器)详解
【STL】list剖析及模拟实现
阿润菜菜的博客
03-11 2989
STL---list的剖析及模拟实现
C++实现STL容器之List
04-08
C++实现STL容器之List
C语言之函数指针（持续更新）
最新发布
qq_47607743的博客
05-20 274
C语言指针
c【语言】了解指针，爱上指针（1）
yzqy_的博客
05-16 905
在计算机中，数据是存储在内存中的，cpu从内存中读取数据，为了方便读取数据，内存又被划分为了一个个的内存单元，一个内存单元的大小就是一字节，一字节等于8bit位，我们给内存进行编号，这个编号就是地址，在c语言中给这个地址起了个名字。是的，亲爱的读者你肯定发现了，&a、p和pc输出的地址是一样的,但&a+1与p+1输出的地址是一样的00EFF940，一次都跳过了4字节，而pc+1输出的却是00EFF93D，一次只跳过一个字节。但是硬件与硬件之间是相互独立的，这该如何实现数据传输呢？”答案当然是否定的。
C语言如何在链表中的指定位置插⼊结点？
PAP
05-15 262
C语言如何在链表中的指定位置插⼊结点？
C语言查漏补缺学习【精简版】
qq_49288362的博客
05-18 620
逗号的组合关系是自左向右，所以左边的表达式会先计算，而右边的表达式的值就留下来作为逗号运算的结果。枚举类型名字通常并不真的使用，要用的是在大括号里的名字，因为它们就是常量符合，它们的类型是int,值则一次从0到n。当要传递的参数的类型比地址大的时候，这是常用的手段：既能用比较少的字节数传递值给参数，又能避免函数对外面的变量的修改。当需要一些可以排列起来的常量值时，定义枚举的意义就是给了这些常量的值的名字。16.*：是一个单目运算符，用来访问指针的值所表示的地址上的变量。
【CCF-CSP】202312-4 宝藏
whaoe_m的博客
05-14 405
对于所有类型为 2的事件，输出一行四个非负整数 C1,1​,C1,2​,C2,1​,C2,2​，表示该时刻的密码 C。西西艾弗岛上埋藏着一份宝藏，小 C 根据藏宝图找到了宝藏的位置。由于小 C 并不会这个问题，他向你发起了求助。你需要帮助小 C 求出所有类型为 22 的事件所对应的密码。小 C 将所有的时刻发生的事件均记录了下来。输入的第一行包含两个正整数n,m。从标准输入读入数据。
C++ 11
qq_65112813的博客
05-17 652
对于类类型，如果定义了接受。
C++中，STL list容器的迭代器实现
05-04
STL中的list容器是一个双向链表，因此它的迭代器也是一个双向迭代器。 list迭代器的定义如下： ```c++ template class list { public: // ... class iterator { public: typedef T value_type; typedef T& ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

初阳hacker

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值