C++ STL之list

最新推荐文章于 2024-04-15 18:19:38 发布
最新推荐文章于 2024-04-15 18:19:38 发布
阅读量1.8k 收藏
点赞数
分类专栏： C++编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ddupd/article/details/11732973
版权 
List 是一个双向的链表，相比较其他容器，list在插入，删除，移动元素时比较好。

1 List 的构造函数：

list( );

explicit list(

   const Allocator& _Al

);

explicit list(

   size_type _Count

);

list(

   size_type _Count,

   const Type& _Val

);

list(

   size_type _Count,

   const Type& _Val,

   const Allocator& _Al

);

list(

   const list& _Right

);

template

   list(

      InputIterator _First,

      InputIterator _Last

   );

template

   list(

      InputIterator _First,

      InputIterator _Last,

      const Allocator& _Al

   );

list(

   list&& _Right

);

2 List的成员变量

value_type

Thefirst template parameter (T)

 

allocator_type

Thesecond template parameter (Alloc)

defaults to:allocator

reference

allocator_type::reference

forthe default allocator:value_type&

const_reference

allocator_type::const_reference

forthe default allocator: constvalue_type&

pointer

allocator_type::pointer

forthe default allocator:value_type*

const_pointer

allocator_type::const_pointer

forthe default allocator: const value_type*

iterator

a bidirectionaliterator to value_type

convertible to const_iterator

const_iterator

a bidirectionaliterator to const value_type

 

reverse_iterator

reverse_iterator

 

const_reverse_iterator

reverse_iterator

 

difference_type

asigned integral type, identical to:iterator_traits::difference_type

usually the same as ptrdiff_t

size_type

anunsigned integral type that can represent any non-negative valueof difference_type

usually the same as size_t

对应变量的用法：

（1）：reference，const_reference

reference back( ); 

const_reference back( ) const;

include 

#include 

 

int main( ) 

{

   using namespace std;

   list  c1;

   

   c1.push_back( 10 );

   c1.push_back( 11 );

 

   int& i = c1.back( );

   const int& ii = c1.front( );

 

   cout << "The last integer of c1 is " << i << endl;

   i--;

   cout << "The next-to-last integer of c1 is " << ii << endl;

}

（2）：difference_type

#include 

#include 

#include 

 

int main( ) 

{

   using namespace std;

 

   list  c1;

   list ::iterator   c1_Iter, c2_Iter;

 

   c1.push_back( 30 );

   c1.push_back( 20 );

   c1.push_back( 30 );

   c1.push_back( 10 );

   c1.push_back( 30 );

   c1.push_back( 20 );

 

   c1_Iter = c1.begin( );

   c2_Iter = c1.end( );

 

    list ::difference_type df_typ1, df_typ2, df_typ3;

 

   df_typ1 = count( c1_Iter, c2_Iter, 10 );

   df_typ2 = count( c1_Iter, c2_Iter, 20 );

   df_typ3 = count( c1_Iter, c2_Iter, 30 );

   cout << "The number '10' is in c1 collection " << df_typ1 << " times.\n";

   cout << "The number '20' is in c1 collection " << df_typ2 << " times.\n";

   cout << "The number '30' is in c1 collection " << df_typ3 << " times.\n";

}

（3）：iterator，const_iterator

#include 

#include 

 

int main( ) 

{

   using namespace std;

   list  c1;

   list ::iterator c1_Iter;

   list ::reverse_iterator c1_rIter;

 

   // If the following line replaced the line above, *c1_rIter = 40;

   // (below) would be an error

   //list ::const_reverse_iterator c1_rIter;

   

   c1.push_back( 10 );

   c1.push_back( 20 );

   c1.push_back( 30 );

   c1_rIter = c1.rbegin( );

   cout << "The last element in the list is " << *c1_rIter << "." << endl;

 

   cout << "The list is:";

   for ( c1_Iter = c1.begin( ); c1_Iter != c1.end( ); c1_Iter++ )

      cout << " " << *c1_Iter;

   cout << endl;

 

   // rbegin can be used to start an iteration through a list in 

   // reverse order

   cout << "The reversed list is:";

   for ( c1_rIter = c1.rbegin( ); c1_rIter != c1.rend( ); c1_rIter++ )

      cout << " " << *c1_rIter;

   cout << endl;

 

   c1_rIter = c1.rbegin( );

   *c1_rIter = 40;

   cout << "The last element in the list is now " << *c1_rIter << "." << endl;

}

（4）size_type  size( ) const;//这个是获取list的容量大小

#include 

#include 

 

int main( )

{

   using namespace std;

   list  c1;

   list ::size_type i;

   

   c1.push_back( 5 );

   i = c1.size( );

   cout << "List length is " << i << "." << endl;

 

   c1.push_back( 7 );

   i = c1.size( );

   cout << "List length is now " << i << "." << endl;

}

（5）value_type//这个表示list中存储元素的类型

#include 

#include 

 

int main( ) 

{

   using namespace std;

   list::value_type AnInt;

   AnInt = 44;

   cout << AnInt << endl;

}

（6）allocator_type

#include 

#include 

 

int main( ) 

{

   using namespace std;

   // The following lines declare objects 

   // that use the default allocator.

   list  c1;

   list  > c2 = list  >( allocator( ) );

 

   // c3 will use the same allocator class as c1

   list  c3( c1.get_allocator( ) );

 

   list::allocator_type xlst = c1.get_allocator( );

   // You can now call functions on the allocator class used by c1

}

3：List的成员函数

（1）      迭代器相关函数

begin   Returniterator to beginning (public member function )

end             Return iterator to end (public member function )

rbegin  Return reverse iterator toreverse beginning (public member function )

rend           Return reverse iterator to reverse end (public member function )

cbegin       Return const_iterator to beginning (public member function )

cend    Return const_iteratorto end (public member function )

crbegin      Return const_reverse_iterator to reversebeginning (public member function )

crend  Return const_reverse_iterator to reverse end (public member function )

const_iterator begin( ) const;

iterator begin( );

const_iterator end( ) const;

iterator end( );

 

const_iterator cbegin( ) const;

const_iterator cend( ) const;

 

const_reverse_iterator rbegin( ) const;

const_reverse_iterator rend( ) const;

 

这里着重接受下cbegin，cend，crbegin，crend，这几个迭代器都是指向恒定内容的，其自身的值可以变化，但是不能修改其指向的内容，下面的这段话说的很清楚，并且有示例代码。

A const_iterator is an iterator that points to const content. Thisiterator can be increased and decreased (unless it is itself alsoconst), just like the iterator returned by list::begin, but it cannot be used to modify the contents itpoints to, even if the list object is not itself const.

#include 

#include 

int main ()

{

  std::list<</span>int> mylist = {5,10,15,20};

  std::cout << "mylist contains:";

  for (auto it = mylist.cbegin(); it != mylist.cend(); ++it)

    std::cout << ' ' << *it;

  std::cout << '\n';

  return 0;

}

当用Cbegin，cend遍历元素时候，不能够修改元素的值，就是因为其实constant_iter,其指向的元素表示恒定的。

（2）      容量相关的函数

empty  Test whether container isempty (public member function )

size            Return size (public member function )

max_size   Returnmaximum size (public member function )

bool empty( ) const;

size_type size( ) const;

size_type max_size( ) const;

 

这里主要说下max_size（）函数，它返回的是容器的最大容量，如下：

#include 

#include 

 

int main( ) 

{

   using namespace std;

   list  c1;

   list ::size_type i;

 

   i = c1.max_size( );

   cout << "Maximum possible length of the list is " << i << "." << endl;

}

结果：

Maximum possible length of the list is 1073741823.

（3）元素获取

front           Access first element (public member function )

back           Access last element (public member function )

reference front( ); 

const_reference front( ) const;

（4）关于修改List以及其元素的函数

Modifiers:

assign         Assign new content to container (public member function )

emplace_front Construct and insert element at beginning(public member function )

push_front  Insert element at beginning (public member function )

pop_front          Delete first element (public member function )

emplace_back  Construct and insert element at the end(public member function )

push_back  Add element at the end (public member function )

pop_back           Delete last element (public member function )

emplace           Construct and insert element (public member function )

insert          Insert elements (public member function )

erase           Erase elements (public member function )

swap                  Swap content (public member function )

resize          Change size (public member function )

clear                   Clear content (public member function )

4.1 assign

template

   voidassign(

     InputIterator _First,

     InputIterator _Last

   );

 

void assign(

   size_type_Count,

   const Type&_Val

);

这个函数的作用就是擦除list中原有的所有元素，然后重新赋值，赋值就是通过上面的两个函数，要么是将一个容器的一定范围的元素赋给List，要么就是将几个相同的值赋给List。

#include

#include

int main()

{

 std::list<</span>int>first;

 std::list<</span>int>second;

  first.assign(7,100);                     // 7 ints with value 100

  second.assign(first.begin(),first.end()); // a copy offirst

  intmyints[]={1776,7,4};

  first.assign(myints,myints+3);           // assigning from array

 

  std::cout <<"Size of first: " <<int (first.size())<< '\n';

  std::cout <<"Size of second: " <<int (second.size())<< '\n';

  return0;

}

4.2 emplace_front

这个就是在List的段首插入一个元素

void emplace_front(

   Type&&_Val

);

4.3emplace_back

这个就是在段末插入一个元素

void emplace_back(

   Type&&_Val

);

#include

#include

int main()

{

  std::list<std::pair<</span>int,char> >mylist;

 

 mylist.emplace_back(10,'a');

 mylist.emplace_back(20,'b');

 mylist.emplace_back(30,'c');

 

  std::cout <<"mylist contains:";

  for(auto& x:mylist)

   std::cout << " (" <<x.first << "," <<x.second << ")";

 

  std::cout <<std::endl;

  return0;

}

4.4 emplace

这个就是在指定的位置插入一个元素

void emplace_back(

   iterator_Where,

   Type&&_Val

);

#include

#include

 

int main()

{

  std::list<std::pair<</span>int,char> >mylist;

 

  mylist.emplace (mylist.begin(), 100, 'x' );

  mylist.emplace (mylist.begin(), 200, 'y' );

 

  std::cout <<"mylist contains:";

  for(auto& x:mylist)

   std::cout << " (" <<x.first << "," <<x.second << ")";

 

  std::cout <<'\n';

  return0;

}

Output:

Output:

mylist contains: (200,y) (100,x)

4.5 push_front

这个函数和emplace_front 类似，同理push_back和emplace_back类似，但是其的区别也是很明显的，emplace系列的函数是直接构造元素然后再插入的，但是push系列的函数是通过复制或者移动存在的元素。

voidpush_front(

   const Type&_Val

);

voidpush_front(

   Type&&_Val

);

4.6 push_back

这个函数顾名思义就在在List的末尾插入一个元素

voidpush_back(

 

voidpush_back(

   Type&&_Val

);

4.7 insert

Insert可以实现在任意的位置插入一个或者多个元素

iteratorinsert(

   const_iterator_Where,

   const Type&_Val

);

iteratorinsert(

   const_iterator_Where,

   Type&&_Val

);

void insert(

   iterator_Where,

   size_type_Count,

   const Type&_Val

);

template

   voidinsert(

     iterator _Where,

     InputIterator _First,

     InputIterator _Last

   );

// inserting into a list

#include

#include

#include

 

int main()

{

  std::list<</span>int>mylist;

 std::list<</span>int>::iterator it;

 

  // set someinitial values:

  for(int i=1;i<=5; ++i) mylist.push_back(i); // 1 2 3 45

 

  it = mylist.begin();

 ++it;      // it points now to number2          ^

 

  mylist.insert(it,10);                       // 1 10 2 3 45

 

  // "it" stillpoints to number2                     ^

  mylist.insert(it,2,20);                     // 1 10 20 20 2 3 4 5

 

 --it;      // it points now to the second20           ^

 

 std::vector<</span>int>myvector (2,30);

  mylist.insert(it,myvector.begin(),myvector.end());

                                               // 1 10 20 30 30 20 2 3 4 5

                                               //              ^

  std::cout <<"mylist contains:";

  for(it=mylist.begin(); it!=mylist.end();++it)

   std::cout << ' ' <<*it;

  std::cout <<'\n';

 

  return0;

}


Output:

mylist contains: 1 10 20 30 30 20 2 3 45

 

4.8 pop_front

删除容器中的第一个元素，同时容器的大小自动减1。

void pop_front();

4.9 pop_back

删除容器中的最后一个元素，同时容器的大小自动减1

void pop_back();

4.10 erase

移除容器中的一个或者多个元素，同时容器的大小自动的减小相应的大小。

iterator erase(

   iterator _Where

);

iterator erase(

   iterator _First,

   iterator _Last

);

函数的返回的是一个迭代器，它指向被删除的最后一个元素的紧挨着的元素。下面的程序很好的说明了erase函数的用法，其中的“^”表示迭代器的指向位置。

#include 

#include 

 

int main ()

{

  std::list<</span>int> mylist;

  std::list<</span>int>::iterator it1,it2;

  // set some values:

  for (int i=1; i<10; ++i) mylist.push_back(i*10);

                              // 10 20 30 40 50 60 70 80 90

  it1 = it2 = mylist.begin(); // ^^

  advance (it2,6);            // ^                 ^

  ++it1;                      //    ^              ^

  it1 = mylist.erase (it1);   // 10 30 40 50 60 70 80 90

                              //    ^           ^

  it2 = mylist.erase (it2);   // 10 30 40 50 60 80 90

                              //    ^           ^

  ++it1;                      //       ^        ^

  --it2;                      //       ^     ^

  mylist.erase (it1,it2);     // 10 30 60 80 90

                              //        ^

  std::cout << "mylist contains:";

  for (it1=mylist.begin(); it1!=mylist.end(); ++it1)

    std::cout << ' ' << *it1;

  std::cout << '\n';

  return 0;

}

4.11 clear

Void clear（）

擦除List中所有的元素。

4.12 resize

void resize(

   size_type _Newsize

);

void resize(

   size_type _Newsize,

   Type _Val

);

当_Newsize大于原容器的大小时，多余的元素会被_val替代，若没有指定_val，会调用默认的构造函数。

#include 

#include 

int main ()

{

  std::list<</span>int> mylist;

  // set some initial content:

  for (int i=1; i<10; ++i) mylist.push_back(i);

  mylist.resize(5);

  mylist.resize(8,100);

  mylist.resize(12);

  std::cout << "mylist contains:";

  for (std::list<</span>int>::iterator it=mylist.begin(); it!=mylist.end(); ++it)

    std::cout << ' ' << *it;

  std::cout << '\n';

  return 0;

}

结果：mylist contains: 1 2 3 4 5 100 100 100 0 0 0 0

4.13 swap

void swap(

   list& _Right

);

friend void swap(

   list& _Left,

   list& _Right

)

交换两个相同类型的List的内容，List中的type和allocator Type都要一致。

（5）List操作相关的函数

5.1 splice

void splice(

   iterator _Where,

   list& _Right

);

void splice(

   iterator _Where,

   list& _Right,

   iterator _First

);

void splice(

   iterator _Where,

   list& _Right,

   iterator _First,

   iterator _Last

);

两个List相互铰接，切记操作完成后两个List中元素总和不变，所以第一个函数调用后，Right变空，第二个函数调用后，Right中少了Iter所指的元素。

#include 

#include 

int main ()

{

  std::list<</span>int> mylist1, mylist2;

  std::list<</span>int>::iterator it;

  // set some initial values:

  for (int i=1; i<=4; ++i)

     mylist1.push_back(i);      // mylist1: 1 2 3 4

 

  for (int i=1; i<=3; ++i)

     mylist2.push_back(i*10);   // mylist2: 10 20 30

  it = mylist1.begin();

  ++it;                         // points to 2

  mylist1.splice (it, mylist2); // mylist1: 1 10 20 30 2 3 4

                                // mylist2 (empty)

                                // "it" still points to 2 (the 5th element)

                                          

  mylist2.splice (mylist2.begin(),mylist1, it);

                                // mylist1: 1 10 20 30 3 4

                                // mylist2: 2

                                // "it" is now invalid.

  it = mylist1.begin();

  std::advance(it,3);           // "it" points now to 30

  mylist1.splice ( mylist1.begin(), mylist1, it, mylist1.end());

                                // mylist1: 30 3 4 1 10 20

  std::cout << "mylist1 contains:";

  for (it=mylist1.begin(); it!=mylist1.end(); ++it)

    std::cout << ' ' << *it;

  std::cout << '\n';

 

  std::cout << "mylist2 contains:";

  for (it=mylist2.begin(); it!=mylist2.end(); ++it)

    std::cout << ' ' << *it;

  std::cout << '\n';

 

  return 0;

}

5.2 remove

void remove (const value_type& val);

删除指定值大小的元素。

5.3 remove_if

template 

void remove_if(

   Predicate _Pred

)

The function calls pred(*i) for each element (where i is an iterator to that element). Any of theelements in the list for which this returns true, are removed from thecontainer.，

_Pred

Unary predicate that, taking a value of the same type asthose contained in the forward_list object,returns truefor those values to beremoved from the container, and false for those remaining.
This can either be a function pointer or a functionobject.

就是说这个_Pred元素必须是一个函数指针或者 函数对象。

#include 

#include 

// a predicate implemented as a function:

bool single_digit (const int& value) { return (value<10); }

// a predicate implemented as a class:

struct is_odd {

  bool operator() (const int& value) { return (value%2)==1; }

};

int main ()

{

  int myints[]= {15,36,7,17,20,39,4,1};

  std::list<</span>int> mylist (myints,myints+8);   // 15 36 7 17 20 39 4 1

  mylist.remove_if (single_digit);           // 15 36 17 20 39

  mylist.remove_if (is_odd());               // 36 20

  std::cout << "mylist contains:";

  for (std::list<</span>int>::iterator it=mylist.begin(); it!=mylist.end(); ++it)

    std::cout << ' ' << *it;

  std::cout << '\n';

 

  return 0;

}

5.4 unique

void unique( );

template

   void unique(

      BinaryPredicate _Pred

   );

下面的源码讲了怎么调用

/ list::unique

#include 

#include 

#include 

// a binary predicate implemented as a function:

bool same_integral_part (double first, double second)

{ return ( int(first)==int(second) ); }

// a binary predicate implemented as a class:

struct is_near {

  bool operator() (double first, double second)

  { return (fabs(first-second)<5.0); }

};

int main ()

{

  double mydoubles[]={ 12.15,  2.72, 73.0,  12.77,  3.14,

                       12.77, 73.35, 72.25, 15.3,  72.25 };

  std::list<</span>double> mylist (mydoubles,mydoubles+10);

    mylist.sort();             //  2.72,  3.14, 12.15, 12.77, 12.77,

                             // 15.3,  72.25, 72.25, 73.0,  73.35

  mylist.unique();           //  2.72,  3.14, 12.15, 12.77

                             // 15.3,  72.25, 73.0,  73.35

  mylist.unique (same_integral_part);  //  2.72,  3.14, 12.15

                                       // 15.3,  72.25, 73.0

  mylist.unique (is_near());           //  2.72, 12.15, 72.25

  std::cout << "mylist contains:";

  for (std::list<</span>double>::iterator it=mylist.begin(); it!=mylist.end(); ++it)

    std::cout << ' ' << *it;

  std::cout << '\n';

 

  return 0;

}

5.5       merge

void merge(

   list& _Right

);

template

   void merge(

      list& _Right, 

      Traits _Comp

   );

Merge和splice有点相似，不过merge是排序的。

#include 

#include 

// compare only integral part:

bool mycomparison (double first, double second)

{ return ( int(first)<</span>int(second) ); }

int main ()

{

  std::list<</span>double> first, second;

  first.push_back (3.1);

  first.push_back (2.2);

  first.push_back (2.9);

  second.push_back (3.7);

  second.push_back (7.1);

  second.push_back (1.4);

  first.sort();

  second.sort();

  first.merge(second);

  // (second is now empty)

  second.push_back (2.1);

  first.merge(second,mycomparison);

  std::cout << "first contains:";

  for (std::list<</span>double>::iterator it=first.begin(); it!=first.end(); ++it)

    std::cout << ' ' << *it;

  std::cout << '\n';

  return 0;

}

5.6 get_allocator

allocator_type get_allocator() const;

#include 

#include 

int main ()

{

  std::list<</span>int> mylist;

  int * p;

  // allocate an array of 5 elements using mylist's allocator:

  p=mylist.get_allocator().allocate(5);

  // assign some values to array

  for (int i=0; i<5; ++i) p[i]=i;

  std::cout << "The allocated array contains:";

  for (int i=0; i<5; ++i) std::cout << ' ' << p[i];

  std::cout << '\n';

  mylist.get_allocator().deallocate(p,5);

  return 0;

}

5.6       =

#include 

#include 

 

int main ()

{

  std::list<</span>int> first (3);      // list of 3 zero-initialized ints

  std::list<</span>int> second (5);     // list of 5 zero-initialized ints

 

  second = first;

  first = std::list<</span>int>();

 

  std::cout << "Size of first: " << int (first.size()) << '\n';

  std::cout << "Size of second: " << int (second.size()) << '\n';

  return 0;

}

 

写到这里终于把所有List的函数用法都写完了，呵呵，还真不少，不过用起来真方便。

 

eskimoer
关注
专栏目录
只是一篇超详细的c++ list用法总结罢了
qq_40692109的博客
04-13 1135
1.简介 list是一个线性双向链表结构，它的数据由若干个节点构成，每一个节点都包括一个信息块（即实际存储的数据）、一个前驱指针和一个后驱指针。使用时需要包含头文件<list>。 它无需分配指定的内存大小且可以任意伸缩，这是因为它存储在非连续的内存空间中，并且由指针将有序的元素链接起来。由于其结构的原因，list随机检索的性能非常的不好，因为它不像vect...
PAT甲级1039 Course List for Student (C++)
小海同学的博客
03-02 133
题意：第一行给出课表有的人数N，总课程数K。 下一行就是K组，每一组包含学生编号，该学生的课程总数，最后给出十一个课程，求每一个课程的人数及编号。 题解：建立哈希数组，利用map进行以ID为下标遍历。 详细代码样例： #include <bits/stdc++.h> using namespace std; int main(){ int N,K; unordered_map <string,set<int>> MAP;//下标为string 用课程为下标查询学生ID
C++ STL 容器技术 之 list双向链表容器
流水不争先
10-17 733
<br />简介：<br />list是双向链表的一个泛化容器，它的数据元素可通过链表指针串接成逻辑意义上的线性表。不同于采用线性表顺序存储结构的vector和deque容器，list双向链表中任一位置的元素查找、插入和删除，都具有高效的常数阶算法时间复杂度O(1)。<br />list应用基础：<br />创建list对象：<br />1、list(const A& a=A()) 创建一个空的list对象。<br />如：list<int> l;<br />2、list(size_type n) 创建一个
c++列表（list)
zbq3025456153的博客
08-08 6937
定义： 列表的核心是一个双向链表，双向开口，可在头、尾两个方向进行元素的插入和删除，因此list除了提供与vector相同的push_back()，和pop_back()，之外还提供在头部进行数据输入输出的操作函数。push_front()和pop_front()。因为链表内存空间不连续，所以不支持随即操作，既没有at()操作也不支持下标访问，只能从头到尾的顺序操作。下面是**的笔记我不是抄袭只是借鉴。...
C++forwart_list
FairLikeSnow的博客
04-12 188
forward_list 的操作比 list 容器还要快，而且占用的内存更少，尽管它在使用上有很多限制，但仅这一点也足以让我们满意了。 #include<iostream> #include<vector> #include <array> #include <list> #include<forward_list> #include ...
c++ STL之list对结构体的增加,删除,排序等操作详解
01-19
对STL中的list进一步学习,编程过程中对结构体的操作很多。 全部代码如下： /* Project:list对结构体的使用 Date: 2018/07/14 Author: Frank Yu 常用函数:int size() 返回容器元素个数；bool empty() 判断容器...
[C++][STL] C++ STL 之 List
03-18
**C++ STL 之 List 知识点详解** C++ Standard Template Library（STL）是C++编程中不可或缺的一部分，它提供了一组高效且可重用的数据结构和算法。其中，`list`容器是STL中的一个核心组件，主要用于处理序列型数据...
C++——STL之list详解
weixin_59055853的博客
12-22 1489
list是一个序列容器，支持常数时间（也就是O(1)）内进行任意位置的插入删除，还支持双向迭代。list容器作为双向链表实现;双向链表可以将它们包含的每个元素存储在不同且不相关的存储位置。与其他基本标准序列容器（array, vector and deque）相比，list在容器内已经获得迭代器的任何位置插入、提取和移动元素时通常表现更好，因此在大量使用这些元素的算法中也是如此，例如排序算法。与其他序列容器相比，主要缺点是它们无法通过其位置直接访问元素;
c++stl之list
爱CV
11-04 384
vector ：vector和built-in数组类似，拥有一段连续的内存空间，能非常好的支持随即存取，即[]操作符，但由于它的内存空间是连续的，所以在中间进行插入和删除会造成内存块的拷贝，另外，当插入较多的元素后，预留内存空间可能不够，需要重新申请一块足够大的内存并把原来的数据拷贝到新的内存空间。这些影响了vector的效率，但是实际上用的最多的还是vector容器，如果不需要去头部和中间插入删除等操作 建议大多数时候使用vector效率。 list： list就是数据结构中的双向链表，因此...
【c++】STL之list用法总结
01-08
与之相似的forward_list是单向链表，可以理解为forward_list是一个行动受限的list，凡是list没提供的功能，forward_list也不提供，forward_list的优点是内存用量少，行动也略快速。 list不支持随机访问。如果你要...
c++ list用法
KEN Bolg
06-19 2615
#include iostream>  #include list>  #include numeric>  #include algorithm>  using namespace std;  //创建一个list容器的实例LISTINT  typedef listint> LISTINT;  //创建一个list容器的实例LISTCHAR  typedef listint
C++ list 使用方法
lq
01-24 3716
C++ list 使用方法使用 list需引入头文件#include <list>引入命名空间 using namespace std;list函数如下//assign() 给list赋值 //back() 返回最后一个元素的引用 //begin() 返回指向容器第一个元素的指针 //clear() 删除所有元素 //empty() 如果l
C++之list用法(一百零二)
Android系统攻城狮
11-12 389
#include <iostream> #include <vector> #include <list> #include <iterator> #include <boost/array.hpp> #include <boost/asio/buffer.hpp> using namespace std; int main(){ int myints[] = {75,23,65,42,13}; std::list<.
【C++ STL】-- list介绍与使用
weixin_64609308的博客
11-02 998
STL的 list 的介绍和使用
C++入门篇9---list
V_zjs的博客
08-16 1426
C++入门篇9 --- list 接口介绍 和 底层实现
C++ STL之List
花季;雨季的博客
09-20 288
List 容器list是C++标准模版库(STL,Standard Template Library)中的部分内容。实际上,list容器就是一个双向链表,可以高效地进行插入删除元素。使用list容器之前必须加上头文件：#include;list属于std命名域的内容，因此需要通过命名限定：using std::list;也可以直接使用全局的命名空间方式：using namespace std;构造函
【C++】STL容器之list
DanteKing的博客
02-08 1310
stl之list的详解和模拟实现
C++修炼之路之list--C++中的双向循环链表
最新发布
Miwll的博客
04-15 685
list简单来说就是数据结构中的双向循环链表，作为链表中的顶级结构，双向循环链表的任意位置插入删除数据效率高，而且不用像单链表那样分情况来讨论插入删除的情况，在C++中经过封装变为了常用的list
【十四】【C++】list 的常见用法
m0_74163972的博客
02-10 3960
是一个双向链表，提供了双向序列的特性，包括有效地进行插入、删除操作等，但不支持随机访问。std::list空初始化：创建了一个空的int类型的list。填充初始化：创建了一个包含 10 个元素，每个元素都初始化为 5 的list。范围初始化：使用的迭代器范围来初始化L3，即将v中的元素复制到L3中。拷贝初始化：使用另一个listL3来初始化L4，复制L3的所有元素。列表初始化 （C++11）:使用初始化列表直接初始化L5。范围for循环： 使用范围for循环遍历L2，打印出其所有元素。
浅谈C++|STL之list+forward_list篇
m0_73731708的博客
09-13 549
将数据进行链式存储（list)是一种物理存储单元上非连续的存储结构，数据元素的逻辑顺序是通过链表中的指针链接实现的链表的组成:链表由—系列组成结点的组成:一个是存储数据元素的，另一个是存储下一个结点地址的STL中的链表是一个由于链表的存储方式并不是连续的内存空间，因此链表list中的迭代器只支持前移和后移，属于双向迭代器·采用动态存储分配，不会造成内存浪费和溢出·链表执行插入和删除操作十分方便，修改指针即可，不需要移动大量元素·链表灵活，但是空间(指针域)和时间(遍历)额外耗费较大。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值