STL 容器使用方法

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

STL容器使用方法


1. vector的使用

vector的主要方法有：constructor（vector()），push_back()，pop_back()，erase()，clear()，insert()，begin()，end()，size()，empty()，front()，back()，resize()，[]

 

#include <iostream>
#include <vector>
#include <algorithm>
 
using namespace std;
 
int main()
{
   int i = 0;
   vector<int> iv(2, 9);      //构造函数，两个大小，初始化为10
   cout << "size = " << iv.size() << endl;
   cout << "capacity = " << iv.capacity() <<endl;
 
   iv.push_back(1);            // 插入元素
   cout << "size = " << iv.size() << endl;
   cout << "capacity = " << iv.capacity() <<endl;
 
   iv.push_back(2);
   cout << "size = " << iv.size() << endl;
   cout << "capacity = " << iv.capacity() <<endl;
 
   iv.push_back(3);
   cout << "size = " << iv.size() << endl;
   cout << "capacity = " << iv.capacity() <<endl;
 
   iv.push_back(4);
   cout << "size = " << iv.size() << endl;
   cout << "capacity = " << iv.capacity() <<endl;
   for( int i = 0; i < iv.size(); i++)     //遍历元素，输出
    {
       cout << iv[i] << ' ';
    }
   cout << endl;
 
   iv.push_back(5);
   cout << "size = " << iv.size() << endl;
   cout << "capacity = " << iv.capacity() <<endl;
   for( int i = 0; i < iv.size(); i++)
    {
       cout << iv[i] << ' ';
    }
   cout << endl;
 
   iv.pop_back();               // 弹出元素
   iv.pop_back();
   cout << "size = " << iv.size() << endl;
   cout << "capacity = " << iv.capacity() <<endl;
 
   iv.pop_back();
   cout << "size = " << iv.size() << endl;
   cout << "capacity = " << iv.capacity() <<endl;
 
   vector<int>::iterator ivIte = find( iv.begin(), iv.end(), 1);   // 定义迭代器，并查找
   if( ivIte != iv.end())
    {
       iv.erase( ivIte);
    }
   cout << "size = " << iv.size() << endl;
   cout << "capacity = " << iv.capacity() <<endl;
   for( int i = 0; i < iv.size(); i++)
    {
       cout << iv[i] << ' ';
    }
   cout << endl;
 
   ivIte = find(iv.begin(), iv.end(), 2);
   if( ivIte != iv.end())
    {
       iv.insert( ivIte, 3, 7);
    }
   cout << "size = " << iv.size() << endl;
   cout << "capacity = " << iv.capacity() <<endl;
   for( int i = 0; i < iv.size(); i++)
    {
       cout << iv[i] << ' ';
    }
   cout << endl;
 
   iv.clear();
   cout << "size = " << iv.size() << endl;
   cout << "capacity = " << iv.capacity() <<endl;
 
   return 0;
} 

运行结果：

        size = 2

        capacity = 2

        size = 3

        capacity = 4

        size = 4

        capacity = 4

        size = 5

        capacity = 8

        size = 6

        capacity = 8

        9 9 1 2 3 4

        size = 7

        capacity = 8

        9 9 1 2 3 4 5

        size = 5

        capacity = 8

        size = 4

        capacity = 8

        size = 3

        capacity = 8

        9 9 2

        size = 6

        capacity = 8

        9 9 7 7 7 2

        size = 0

        capacity = 8


2. list的使用

 

#include <iostream>
#include <list>
#include <iostream>
#include <algorithm>
 
using namespace std;
 
int main()
{
   int i = 0;
   list<int> ilist;
   cout << "size = " << ilist.size() << endl;
 
   ilist.push_back(0);
   ilist.push_back(1);
   ilist.push_back(2);
   ilist.push_back(3);
   ilist.push_back(4);
   cout << "size = " << ilist.size() << endl;
 
   list<int>::iterator ite;
   for( ite = ilist.begin(); ite != ilist.end(); ++ite)
    {
       cout << *ite << ' ';
    }
   cout << endl;
 
   ite = find(ilist.begin(), ilist.end(), 3);
   if( ite != ilist.end())
    {
       ilist.insert(ite, 99);
    }
   cout << "size = " << ilist.size() << endl;
   cout << *ite << endl;
 
   for( ite = ilist.begin(); ite != ilist.end(); ++ite)
    {
       cout << *ite << ' ';
    }
   cout << endl;
 
   ite = find(ilist.begin(), ilist.end(), 1);
   if(ite != ilist.end())
    {
       cout << *( ilist.erase(ite)) << endl;
    }
 
   for(ite = ilist.begin(); ite != ilist.end(); ++ite)
    {
       cout << *ite << ' ';
    }
   cout << endl;
 
   return 0;
}

运行结果：

       size = 0

       size = 5

       0 1 2 3 4

       size = 6

       3

       0 1 2 99 3 4

       2

       0 2 99 3 4

 

3. deque的使用

#include <iostream>
#include <deque>
#include <algorithm>
#include <memory>
using namespace std;
 
int main()
{
   deque<int, allocator<int> > ideq(20, 9);
   cout << "size = " << ideq.size() << endl;
 
   for( int i = 0; i < ideq.size(); i++)
    {
       ideq[i] = i;
    }
   for( int i = 0; i < ideq.size(); i++)
    {
       cout << ideq[i] << ' ';
    }
   cout << endl;
 
   for( int i = 0; i < 3; i++)
    {
       ideq.push_back(i);
    }
   for( int i = 0; i < ideq.size(); i++)
    {
       cout << ideq[i] << ' ';
    }
   cout << endl;
   cout << "size = " << ideq.size() << endl;
 
   ideq.push_back(3);
   for( int i = 0; i < ideq.size(); i++)
    {
       cout << ideq[i] << '';
    }
   cout << endl;
   cout << "size = " << ideq.size() << endl;
 
   ideq.push_front(99);
   for( int i = 0; i < ideq.size(); i++)
    {
       cout << ideq[i] << ' ';
    }
   cout << endl;
   cout << "size = " << ideq.size() << endl;
 
   ideq.push_front(98);
   ideq.push_front(97);
   for( int i = 0; i < ideq.size(); i++)
    {
       cout << ideq[i] << ' ';
    }
   cout << endl;
   cout << "size = " << ideq.size() << endl;
 
 
   deque<int, allocator<int> >::iterator itr;
   itr = find(ideq.begin(), ideq.end(), 99);
   cout << *itr << endl;
   // cout << *(itr.) <<endl;
 
   return 0;
} 

运行结果：

        size = 20

        0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19

        0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 0 1 2

        size = 23

        0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 0 1 2 3

        size = 24

        99 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 0 1 2 3

        size = 25

        97 98 99 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 0 1 2 3

        size = 27

        99

4. stack的使用

#include <iostream>
#include <algorithm>
#include <stack>
#include <list>
 
using namespace std;
 
int main()
{
   stack<int, list<int> > myStack;
   myStack.push(1);
   myStack.push(3);
   myStack.push(5);
   myStack.push(7);
   cout << myStack.size() << endl;
   cout << myStack.top() << endl;
 
   myStack.pop();   cout <<myStack.top() << endl;
   myStack.pop();   cout <<myStack.top() << endl;
   myStack.pop();   cout <<myStack.top() << endl;
   cout << myStack.size() << endl;
 
   return 0;
} 

结果：

        4

        7

        5

        3

        1

        1 

5. queue的使用

 

#include <iostream>
#include <queue>
#include <list>
 
using namespace std;
 
int main()
{
    queue<int, list<int> > iqueue;              //注意 两个 > 号不能连着出现，否则出错
   iqueue.push(1);
   iqueue.push(3);
   iqueue.push(5);
   iqueue.push(7);
 
   cout << iqueue.size() << endl;
   cout << iqueue.front() << endl;
 
   iqueue.pop(); cout << iqueue.front() << endl;
   iqueue.pop(); cout << iqueue.front() << endl;
   iqueue.pop(); cout << iqueue.front() << endl;
   cout << iqueue.size() << endl;
 
   return 0;
}

程序结果:

        4

        1

        3

        5

        7

        1 

6. heap的使用

#include <iostream>
#include <vector>
#include <algorithm>
 
using namespace std;
 
int main()
{
    {
   // test heap 以vector为容器
   int ia[9] = {0, 1, 2, 3, 4, 8, 9, 3, 5};
   vector<int> ivec(ia, ia+9);
 
   make_heap(ivec.begin(), ivec.end());
   for(int i = 0; i < ivec.size(); ++i)
    {
       cout << ivec[i] << ' ';
    }
   cout << endl;
 
   ivec.push_back(7);
   push_heap(ivec.begin(), ivec.end());
   for(int i = 0; i < ivec.size(); ++i)
    {
       cout << ivec[i] << ' ';
    }
   cout << endl;
 
   pop_heap(ivec.begin(), ivec.end());
   cout << ivec.back() << endl;    // return，但是没有删除
   ivec.pop_back();                //真正删除该元素
   for(int i = 0; i < ivec.size(); ++i)
    {
       cout << ivec[i] << ' ';
    }
   cout << endl;
 
   sort_heap(ivec.begin(), ivec.end());
   for(int i = 0; i < ivec.size(); ++i)
    {
       cout << ivec[i] << ' ';
    }
   cout << endl;
    }
 
    {
   //  test heap，以array为底层容器
   int ia[9] = {0, 1, 2, 3, 4, 8, 9, 3, 5};
   make_heap(ia, ia+9);
   // array无法改变大小，因此不可以对满载的array进行push_heap()操作
 
   sort_heap(ia, ia+9);
   for( int i = 0; i < 9; ++i)
    {
       cout << ia[i] << ' ';
    }
   cout << endl;
    }
 
    {
   // test heap
   int ia[6] = {4, 1, 7, 6, 2, 5};
   make_heap(ia, ia + 6);
   for( int i = 0; i < 6; ++i)
    {
       cout << ia[i] << ' ';
    }
   cout << endl;
    }
 
   return 0;
} 

程序结果：

        9 5 8 3 4 0 2 3 1

        9 7 8 3 5 0 2 3 1 4

        9

        8 7 4 3 5 0 2 3 1

        0 1 2 3 3 4 5 7 8

        0 1 2 3 3 4 5 8 9

        7 6 5 1 2 4

 

priority-heap的使用

 

#include <iostream>
#include <queue>
#include <algorithm>
 
using namespace std;
 
int main()
{
       //大顶堆
   int ia[9] = {0, 1, 2, 3, 4, 8, 9, 3, 5};
   priority_queue<int> ipq(ia, ia+9);
   cout << "size = " << ipq.size() << endl;
 
   for(int i = 0; i < ipq.size(); ++i)
    {
       cout << ipq.top() << ' ';
    }
   cout << endl;
 
   while(!ipq.empty())
    {
       cout << ipq.top() << ' ';
       ipq.pop();
    }
   cout << endl;
      
       //小顶堆
   priority_queue< int, vector<int>, greater<int> >ipq_min(ia, ia+9);
   cout << "size = " << ipq_min.size() << endl;
 
   for(int i = 0; i < ipq_min.size(); ++i)
    {
       cout << ipq_min.top() << ' ';
    }
   cout << endl;
 
   while(!ipq_min.empty())
    {
       cout << ipq_min.top() << ' ';
       ipq_min.pop();
    }
   cout << endl;
   return 0;
}

程序结果：

        size = 9

        9 9 9 9 9 9 9 9 9

        9 8 5 4 3 3 2 1 0

        size = 9

        0 0 0 0 0 0 0 0 0

        0 1 2 3 3 4 5 8 9

 7. set和map的使用

 set使用：

#include <iostream>
#include <set>
#include <algorithm>
 
using namespace std;
 
int main()
{
   int i;
   int ai[5] = {0, 1, 2, 3, 4};
   set<int> iset(ai, ai+5);
 
   cout << "size = " << iset.size() << endl;
   cout << "3 count = " << iset.count(3) <<endl;
   iset.insert(3);
   cout << "size = " << iset.size() << endl;
   cout << "3 count = " << iset.count(3) <<endl;
 
   iset.erase(1);
   cout << "size = " << iset.size() << endl;
   cout << "3 count = " << iset.count(3) <<endl;
   cout << "1 count = " << iset.count(1) <<endl;
 
   set<int>::iterator ite1 = iset.begin();
   set<int>::iterator ite2 = iset.end();
   for( ; ite1 != ite2; ++ite1)
    {
       cout << *ite1;
    }
   cout << endl;
 
   ite1 = find(iset.begin(), iset.end(), 3);
   if( ite1 != iset.end())
       cout << "3 found" << endl;
 
   ite1 = find(iset.begin(), iset.end(), 1);
   if( ite1 != iset.end())
       cout << "1 not found" << endl;
 
   // *ite1 = 9;   编译错误，只读迭代器无法修改对应的元素
 
   return 0;
}

程序结果：

        size = 5

        3 count = 1

        size = 5

        3 count = 1

        size = 4

        3 count = 1

        1 count = 0

        0234

        3 found

 

Map的使用：

#include <iostream>
#include <map>
#include <string>
using namespace std;
 
int main()
{
   map<string, int> simap;    // 以string为键值，以int为实值
   simap[string("jjhou")] = 1;
   simap[string("jerry")] = 2;
   simap[string("jason")] = 3;
   simap[string("jimmy")] = 4;
 
   pair<string, int> value(string("david"), 5);
   simap.insert(value);
 
    map<string,int>::iterator simap_iter = simap.begin();
   for( ; simap_iter != simap.end(); ++simap_iter)
    {
       cout << simap_iter->first << ' ' <<simap_iter->second << endl;
    }
 
   int number = simap[string("jerry")];
   cout << number << endl;
 
   map<string, int>::iterator ite1;
   // 面对关联式容器，应该使用其所提供的find 函数搜寻元素，会比使用STL算法find更有效率
   ite1 = simap.find(string("mchen"));
   if( ite1 == simap.end())
       cout << "mchen not found" << endl;
 
   ite1 = simap.find(string("jerry"));
   if( ite1 != simap.end())
       cout << "jerry found" << endl;
 
   ite1->second = 9;
   number = simap[string("jerry")];
   cout << number <<endl;
 
   return 0;
}

程序结果：

        david 5

        jason 3

        jerry 2

        jimmy 4

        jjhou 1

        2

        mchen not found

        jerry found

        9

 

8. hashtable的使用：

#include <iostream>
#include <hash_set.h>
using namespace std;
 
int main()
{
   hashtable<int, int, hash<int>, identity<int>,equal_to<int>, allocator<int> > iht(50, hash<int>(),equal_to<int>());
   cout << iht.size() << endl;
   cout << iht.bucket_count() << endl;
   cout << iht.max_bucket_count() << endl;
 
   iht.insert_unique(59);
   iht.insert_unique(63);
   iht.insert_unique(108);
   iht.insert_unique(2);
   iht.insert_unique(53);
   iht.insert_unique(55);
 
   cout << iht.size() << endl;
 
   hashtable<int, int, hash<int>, identity<int>,equal_to<int>, allocator<int> >::iterator ite = iht.begin();
 
   for( int i = 0; i < iht.size(); ++i, ++ite)
       cout << *ite << ' ';
   cout << endl;
 
   for( int i = 0; i < iht.bucket_count(); ++i)
    {
       int n = iht.elems_in_bucket(i);
       if( n != 0)
           cout << "bucket[" << i << "] has "<< n << "elems." << endl;
    }
 
   for( int i = 0; i <= 47; i++)
    {
       iht.insert_equal(i);
    }
   cout << iht.size() << endl;
   cout << iht.bucket_count() << endl;
 
   for( int i = 0; i < iht.bucket_count(); i++)
    {
       int n = iht.elems_in_bucket(i);
       if( n != 0)
           cout << "bucket[" << i << "] has "<< n << "elems." << endl;
    }
 
   ite = iht.begin();
   for( int i = 0; i < iht.size(); ++i, ++ite)
       cout << *ite << endl;
   cout << endl;
 
   cout << *(iht.find(2)) << endl;
   cout << iht.count(2) << endl;
 
   return 0;
 
}

程序结果：

        0

        53

        4294967291

        6

        53 55 2 108 59 63

        bucket[0] has 1elems.

        bucket[2] has 3elems.

        bucket[6] has 1elems.

        bucket[10] has 1elems.

        54

        97

        bucket[0] has 1elems.

        bucket[1] has 1elems.

        bucket[2] has 2elems.

        bucket[3] has 1elems.

        bucket[4] has 1elems.

        bucket[5] has 1elems.

        bucket[6] has 1elems.

        bucket[7] has 1elems.

        bucket[8] has 1elems.

        bucket[9] has 1elems.

        bucket[10] has 1elems.

        bucket[11] has 2elems.

        bucket[12] has 1elems.

        bucket[13] has 1elems.

        bucket[14] has 1elems.

        bucket[15] has 1elems.

        bucket[16] has 1elems.

        bucket[17] has 1elems.

        bucket[18] has 1elems.

        bucket[19] has 1elems.

        bucket[20] has 1elems.

        bucket[21] has 1elems.

        bucket[22] has 1elems.

        bucket[23] has 1elems.

        bucket[24] has 1elems.

        bucket[25] has 1elems.

        bucket[26] has 1elems.

        bucket[27] has 1elems.

        bucket[28] has 1elems.

        bucket[29] has 1elems.

        bucket[30] has 1elems.

        bucket[31] has 1elems.

        bucket[32] has 1elems.

        bucket[33] has 1elems.

        bucket[34] has 1elems.

        bucket[35] has 1elems.

        bucket[36] has 1elems.

        bucket[37] has 1elems.

        bucket[38] has 1elems.

        bucket[39] has 1elems.

        bucket[40] has 1elems.

        bucket[41] has 1elems.        

        bucket[42] has 1elems.

        bucket[43] has 1elems.

        bucket[44] has 1elems.

        bucket[45] has 1elems.

        bucket[46] has 1elems.

        bucket[47] has 1elems.

        bucket[53] has 1elems.

        bucket[55] has 1elems.

        bucket[59] has 1elems.

        bucket[63] has 1elems.

        0

        1

        2

        2

        3

        4

        5

        6

        7

        8

        9

        10

        11

        108

        12

        13

        14

        15

        16

        17

        18

        19

        20

        21

        22

        23

        24

        25

        26

        27

        28

        29

        30

        31

        32

        33

        34

        35

        36

        37

        38

        39

        40

        41

        42

        43

        44

        45

        46

        47

        53

        55

        59

        63

 

        2

        2

 Hash_set的使用：

#include <iostream>
#include <hash_set.h>
#include <cstring>
 
using namespace std;
 
struct eqstr
{
   bool operator() (const char* s1, const char* s2) const
    {
       return strcmp(s1, s2) == 0;
    }
};
 
void lookup( const hash_set<const char*, hash<const char*>, eqstr>& Set, const char* word)
{
   hash_set<const char*, hash<const char*>,eqstr>::const_iterator it = Set.find(word);
   cout << "  "<< word << ": " << (it != Set.end()?"present" : "not present") << endl;
}
 
int main()
{
 
   hash_set<const char*, hash<const char*>, eqstr> Set;
   Set.insert("kiwi");
   Set.insert("plum");
   Set.insert("apple");
   Set.insert("mango");
    Set.insert("apricot");
   Set.insert("banana");
 
   lookup(Set, "mango");
   lookup(Set, "apple");
   lookup(Set, "durian");
 
   hash_set<const char*, hash<const char*>, eqstr>::iteratorite1 = Set.begin();
   hash_set<const char*, hash<const char*>, eqstr>::iteratorite2 = Set.end();
   for(; ite1 != ite2; ++ite1)
    {
       cout << *ite1 << ' ';
    }
 
   return 0;
}

程序结果：

       mango: present

       apple: present

       durian: not present

       banana plum mango apple kiwi apricot

 

 

hash_map的使用：

#include <iostream>
#include <hash_map.h>
#include <cstring>
 
using namespace std;
 
struct eqstr
{
   bool operator() (const char* s1, const char* s2) const
    {
       return strcmp(s1, s2) == 0;
    }
};
 
int main()
{
   hash_map<const char*, int, hash<const char*>, eqstr> days;
 
   days["january"] = 31;
   days["february"] = 28;
   days["march"] = 31;
   days["april"] = 30;
   days["may"] = 31;
   days["june"] = 30;
   days["july"] = 31;
   days["august"] = 31;
   days["september"] = 30;
   days["october"] = 31;
   days["november"] = 30;
   days["december"] = 31;
 
   cout << "september -> " <<days["september"] << endl;
   cout << "june -> " << days["june"]<< endl;
   cout << "february -> " <<days["february"] << endl;
   cout << "december -> " <<days["december"] << endl;
 
   hash_map<const char*, int, hash<const char*>,eqstr>::iterator ite1 = days.begin();
   hash_map<const char*, int, hash<const char*>,eqstr>::iterator ite2 = days.end();
   for(; ite1 != ite2; ++ite1)
    {
       cout << ite1->first << ' ';
    }
 
   return 0;
}

程序结果：

       september -> 30

       june -> 30

       february -> 28

       december -> 31

       september june july may january februarydecember march april november october a

       august

 

 

 


xiao_0429
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
STL中常用容器的使用方法
qq_20110551的博客
08-10 359
STL中常用容器的使用方法 map Map是STL的一个关联容器，它提供一对一（其中第一个可以称为关键字，每个关键字只能在map中出现一次，第二个可能称为该关键字的值）的数据 处理能力，由于这个特性，它完成有可能在我们处理一对一数据的时候，在编程上提供快速通道。这里说下map内部数据的组织，map内部自建一颗红黑树(一 种非严格意义上的平衡二叉树)，这颗树具有对数据自动排序的功能，所以在map...
STL源码剖析-hashtable
常思考->有目标->重实践->善反思
07-01 1008
hashtable(散列表)结构，在插入、删除、搜索等操作也具有”常数平均时间”的表现。 hashtable概述 举个例子，假设所有元素都是16bits，范围0~65535,简单的使用一个array即可以满足常数时间的插入、删除、搜索。 创建数组array A,拥有65536个元素，索引号码0~65535，初始值全部为0 当插入元素i就执行A[i]++，删除元素就执行A[i]–，如果搜...
《STL源码剖析》学习笔记——第五章：关联式容器 hashtable
baidu_15952103的博客
11-12 220
目录 1. hashtable概述 2. hashtable的迭代器 3. hashtable的操作 3.1 构造函数 3.2 析构函数 3.3 插入元素 3.3.1 insert_unique 3.3.2 insert_equal 3.4 删除元素 1. hashtable概述 hashtable在插入，删除，搜寻等操作上具有＂常数平均时间＂的表现，而且这种表现以统计为基础，不依赖输入元素的随机性。（二叉搜索树具有对数平均时间的表现，是建立在输入数据有足够随机性的基础上。） has
STL 中容器的一些简单操作
小驴的专栏
03-14 724
<br />STL （Standard Template Library）标准模板库，它是C++编程中一个很重要的分支。<br />我们可以人为的把它分为以下三个部分:<br />算法：包含的头文件有<algorithm>，<numeric>和<functional>。<br />容器：包含的头文件有<vector>,<list>,<deque>,<set>,<map>,<stack>和<queue>。<br />迭代器：包含的头文件有<utility>,<iterator>和<memory>。<br />
STL常用容器用法大全
星夜不语秋声
01-26 2385
STL容器常见用法集合
C++——STL容器
JAN6055的博客
02-01 5613
STL容器的介绍 vector, queue, deque, priority_queue, list, map 等等
C++ STL 容器基本使用详解：
anana125的博客
02-07 5235
C++ STL 容器： C++ STL vector 容器 vector容器的概念 vector在英文中是矢量的意思。 我们知道，一个数组必须要有固定的长度，在开一个数组的时候，这个长度也就被静态地确定下来了。但是vector却是数组的“加强版”，对于一组数据来讲，你往vector里存多少数据，vector的长度就有多大。也就是说，我们可以将其理解为一个“变长数组”。 事实上，vector的实现方...
STL常用容器——map容器的使用
万里顾一程的博客
10-25 2437
map容器是存储pair 类型键值对（ pair 类模板创建的 pair 对象）的关联式容器。pair 键值对（pair）：键值对中第一个元素为key(键)，起查找作用，第二个元素为value(值)。使用 map 容器存储的各个键值对，键的值既不能重复也不能被修改。在使用 map 容器存储多个键值对时，默认情况下会自动根据各键值对的键的大小，对所有键值对做升序排序。
C++的STL容器类详解
最新发布
Jinyizhi2233的博客
07-11 3473
STL（Standard Template Library）是C++标准库中的一个重要组成部分，它提供了一组通用的模板类和函数，用于实现常用的数据结构和算法。（Containers）：STL提供了多种容器类，如向量（vector）、链表（list）、双向链表（deque）、集合（set）、映射（map）等。总而言之，STL是C++开发中非常重要的工具之一，它提供了高效的数据结构和算法，能够提高程序的性能、减少开发时间，并提高代码的重用性和可维护性。这样可以大大提高代码的重用性，减少了开发时间和维护成本。
STL容器
g498912529的博客
08-01 4745
STL容器底层知识
STL容器的一些使用简介
06-15
"STL容器的一些使用简介" STL（Standard Template Library）是C++标准库中的一部分，提供了一些常用的数据结构和算法。今天，我们将介绍STL容器的一些使用简介。 首先， lets talk about setprecision。这是一个...
STL容器使用代码
01-05
STL（Standard Template Library，标准模板库）是C++编程语言中的一个重要组成部分，它提供了高效且灵活的数据结构和算法。在STL中，容器是一类能够...通过学习这些代码，你可以更好地理解STL容器的API和实际操作方式。
STL常用容器详细解析
01-20
STL是C/C++开发中一个非常重要的模板，而其中定义的各种容器也是非常方便我们大家使用。下面，我们就浅谈某些常用的容器。这里我们不涉及容器的基本操作之类，只是要讨论一下各个容器其各自的特点。STL中的常用容器...
stl_set容器详细使用方法
04-28
STL Set 容器详细使用方法 STL（Standard Template Library）中的 Set 容器是一种关联容器，用于存储唯一的元素，且自动排序。下面是 STL Set 容器的详细使用方法。 元素类型 Set 容器中元素的类型可以是任何类型...
C/C++标准输入输出与文件输入输出
热门推荐
Fly Follow the Heart
09-29 2万+
C语言输入输出函数有很多，标准I/O函数中包含了如下几个常用的函数： 标准输入输出： 1. scanf, printf int scanf(const char *format, arg_list) scanf主要从标准输入流中获取参数值，format为指定的参数格式及参数类型，如scanf("%s,%d",str,icount); 它要求在标准输入流中输入类似"son
关于DLL导出函数的总结
Fly Follow the Heart
08-12 1万+
一直在鼓捣DLL，每天的工作都是调试一个一个的DLL，往DLL里面添加自己的代码，但是对于DLL一直不太了解啊！今天一查资料，才发现自己对于DLL编写的一些基本知识也不了解。要学习，这篇文章先总结DLL的导出函数的方法。         首先说一下如何建立DLL工程！
C和C++中的一些问题
Fly Follow the Heart
05-14 8381
C和C++中的一些问题 1. C语言是否可以进行重载？ 测试代码如下：     #include     #include     int f(int a, char b)     {         return a;     }     float f(int a, float b)     {         return b;     }
RakNet的配置
Fly Follow the Heart
06-17 2928
RakNet的配置      毕业设计完成了。自己使用RakNet中的一些笔记跟大家分享一下。 1.使用源码：        先说使用源码的好处： 使用源码，在调试程序时可以追踪源码内的函数。这是对学习RakNet有很大的好处的，否则只知道程序可以执行，对于调用过程无处追踪。     1. 将下载文件夹下/Source 下的源码加入工程。     2. 在Linker->Addition
深度剖析C++模型对象
Fly Follow the Heart
06-18 2063
1. C++对象模型：        其他的两种曾经提出的对象模型：        1. 简单对象模型：               对象是一个slot集合，每一个slot即一个指针，指向成员变量或成员函数                        如下图所示，对象是由一系列slot组成，一个slot执行一个类方法或类变量。               2.
STL容器使用时机详解：从入门到提高
本资源是一份关于C++标准模板库（STL）入门及提高的...这份PPT旨在帮助读者掌握STL容器的使用时机，通过理解抽象的重要性以及不同编程范式的演变，引导读者逐步深入理解并运用STL这一强大的工具，从而提高C++编程能力。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值