C++中的容器

C++中的容器

容器与容器适配器

容器包括vector, deque, list, map, multimap, set, multiset。容器适配器包括基于deque的stack和queue,基于vector的priority_queue。string也实现了stl的接口。

因为编写C++程序时经常需要查找容器的函数接口,故作此总结。C++新引入的容器与函数未引入。主要参考自:STL Containers and Container
Adaptors

序列容器

包括vector,deque,list

共有函数

  • 构造函数

    ContainerType<T> c;
    ContainerType<T> c(num);
    ContainerType<T> c(num, val);
    ContainerType<T> c(inIterBegin, inIterEnd);
    //复制构造函数
    ContainerType<T> c(otherLikeContainer);
    ContainerType<T> c = otherLikeContainer;
  • 赋值构造函数
    c1 = c2
  • 比较运算
    c1 == c2
    c1 != c2
    c1 < c2 //按元素逐个比较
    c1 <= c2
    c1 > c2
    c1 >= c2
  • 容量
    empty()
    size()
    max_size()
    resize(num, val = default)
  • 迭代器和引用
    begin()
    end()
    rbegin()
    rend()
    front()
    back()
  • 插入值
    push_back(val)
    insert(iter, val)
    insert(iter, num, val)
    insert(iter, inIterBegin, inIterEnd)
  • 赋值(换掉容器内所有元素)
    assign(inIterBegin, inIterEnd)
    assign(num, val)
  • 删除元素
    pop_back()
    erase(iter)
    erase(iterBegin, iterEnd)
    clear()
  • 其他
    swap(otherLikeContainer)
    get_allocator()

特有函数

  • vector特有

    reserve(num)
    capacity()
  • list特有
    merge(otherList) //按照大小顺序合并,二者必须是有序的
    merge(otherList, binPred)
    remove(val)
    remove_if(unPred)
    reverse()
    sort()
    sort(binPred)
    splice(iter, otherList) //将otherList中所有元素移动到iter处
    splice(iter, otherList, otherIterBegin, otherIterEnd)
    unique()
    unique(binPred)
  • vector和deque特有
    at(index) //会检查下标范围
    operator[](index)
  • deque和list特有
    push_front(val)
    pop_front()

容器适配器

包括stack,queue,priority_queue

共有函数

c1 = c2
empty()
size()
push(val)
pop()

特有函数

  • queue特有函数

    front()
    back()
  • stack和priority_queue 特有函数
    top()
    ==
    !=
    <
    <=
    >
    >=

序列容器与容器适配器函数表格

参见The STL Sequential Containers and Container Adaptors,

and their Member Functions

关联容器

包括map, multimap, set, multiset

共有函数

  • 赋值

    c1 = c2
  • 比较
    ==
    !=
    <
    <=
    >
    >=
  • 容量
    empty() const
    size() const
    max_size()
  • 迭代器
    begin()
    end()
    rbegin()
    rend()
  • 插入值
    insert(p, val)
    insert(start, end)
  • 删除
    erase(someKey)
    erase(iter)
    erase(start, end)
    clear()
  • 查找
    count(someKey)
    find(someKey)  //返回迭代器
    lower_bound(someKey) //大于等于someKey的迭代器
    upper_bound(someKey) //大于someKey的迭代器
    equal_range(someKey)
  • 其他
    swap(otherLikeContainer)
    get_allocator()
    //key和val比较的函数对象
    key_comp()
    value_comp()

特有函数

其实不存在特有函数,只是这些函数的接口略有不同

  • map/multimap特有构造函数

    ContainerType<keyType, ValueType> c;
    ContainerType<KeyType, ValueType> c(inIterBegin, inIterEnd);
    ContainerType<KeyType, ValueType> c(otherLikeContainer);
  • set/multiset特有构造函数
    ContainerType<T> c;
    ContainerType<T> c(inIterBegin, inIterEnd);
    ContainerType<T> c(otherLikeContainer);
  • map特有成员函数
    operator[someKey]
  • map/set特有成员函数
    //返回值为pair<iterator, true/false(是否已经含有此值)>
    insert(val)
  • multimap/multiset特有成员函数
    //返回iterator
    insert(val)

关联容器函数表格

参见The STL Associative Containers and their Member Functions

其他

包括string,bitset等类容器

string

  • 构造函数

    string s;
    string s(c_string_value);
    string s(char_array, size_type_count);
    string s(string_value);
    string s(string_value, size_type_index);
    string s(string_value, size_type_index, size_type_count);
    string s(size_type_count, char_value);
    string s(input_iterator_start, input_iterator_end);
  • 取char
    s[i]
    s.at(i) //边界检查
  • 迭代器
    s.begin()
    s.end()
    s.rbegin()
    s.rend()
  • append与赋值
    operator+=
    s.append(string_value)
    s.append(c_string_value)
    s.append(size_type_count, char_value)
    s.append(c_string_value, size_type_count)
    s.append(c_string_value, size_type_index, size_type_count)
    s.append(first_input_iterator, last_input_iterator)
    //
    operator=
    s.assign(string_value)
    s.assign(c_string_value)
    s.assign(size_type_count, char_value)
    s.assign(c_string_value, size_type_count)
    s.assign(c_string_value, size_type_index, size_type_count)
    s.assign(start_input_iterator, end_input_iterator)
  • 转换为c-string
    s.copy(char_array, size_type_count, size_type_index)
    s.c_str() //返回以\0结束的char数组地址,数组归s所有,不要更改
    s.data() //返回不以\0结束的char数组地址,数组归s所有,不要更改
  • 子串
    s.substr(size_type_index)
    s.substr(size_type_index, size_type_count)
  • 容量及调整容量
    s.empty()
    s.capacity()
    s.length()
    s.size()
    s.max_size()
    s.reserve(size_type_value)
    s.resize(size_type_value, char_value)
    s.resize(size_type_value)
  • 删除
    s.clear()
    s.erase() //删除所有字符
    s.erase(size_type_index)
    s.erase(size_type_index, size_type_count)
    s.erase(iterator_position)
    s.erase(first_iterator, last_iterator)
  • 查找
    //所有的find均返回下标值,若找不到,返回string::npos
    //
    //查找char
    s.find(char_value)
    s.find(char_value, size_type_index)
    s.rfind(char_value)
    s.rfind(char_value, size_type_index)
    //
    //查找string
    s.find(string_value)
    s.find(string_value, size_type_index) //从index处开始查找
    //从后向前查找
    s.rfind(string_value)
    s.rfind(string_value, size_type_index)
    //查找cstring
    s.find(c_string_value, size_type_index, size_type_count)
    s.rfind(c_string_value, size_type_index, size_type_count)
    //
    s.find_first_of(char_value)
    s.find_first_of(char_value, size_type_index)
    s.find_first_not_of(char_value)
    s.find_first_not_of(char_value, size_type_index)
    //
    //查找在/不在string中的char,返回下标
    s.find_first_of(string_value)
    s.find_first_of(string_value, size_type_index)
    s.find_first_not_of(string_value)
    s.find_first_not_of(string_value, size_type_index)
    //
    s.find_first_of(c_string_value, size_type_index, size_type_count)
    s.find_first_not_of(string_value, size_type_index, size_type_count)
    //
    s.find_last_of(char_value)
    s.find_last_of(char_value, size_type_index)
    s.find_last_not_of(char_value)
    s.find_last_not_of(char_value, size_type_index)
    //
    s.find_last_of(string_value)
    s.find_last_of(string_value, size_type_index)
    s.find_last_not_of(string_value)
    s.find_last_not_of(string_value, size_type_index)
    //
    s.find_last_of(c_string_value, size_type_index, size_type_count)
    s.find_last_not_of(string_value, size_type_index, size_type_count)
  • 插入值
    s.insert(size_type_index, string_variable)
    s.insert(size_type_index, c_string_value)
    s.insert(size_type_index1, string_variable,  size_type_index2, size_type_count)
    s.insert(size_type_index, c_string_value, size_type_count)
    s.insert(size_type_index, size_type_count, char_value)//c++中函数形参总是count在val之前
    s.insert(iterator_position, size_type_count, char_value)
    s.insert(iterator_position, char_value)
    s.insert(iterator_position, input_iterator_first, input_iterator_last)
    //
    s.push_back(char_value)
  • 字符/字符串替换
    s.replace(size_type_index, size_type_count, string_value)
    s.replace(iterator_first, iterator_last, string_value
    s.replace(size_type_index1, size_type_count1, string_value,
            size_type_index2, size_type_count2)
    s.replace(size_type_index, size_type_count, c_string_value)
    s.replace(iterator_first, iterator_last, c_string_value)
    s.replace(size_type_index, size_type_count1,
            c_string_value, size_type_count2)
    s.replace(iterator_first, iterator_last,
            c_string_value, size_type_count)
    s.replace(size_type_index, size_type_count1,
            size_type_count2, char_value)
    s.replace(iterator_first, iterator_last,
            size_type_count, char_value)
    s.replace(iterator_first, iterator_last,
            input_iterator_start, input_iterator_end)
  • 比较
    //==, !=, <, > <=, >=已经重载
    //
    //compare返回值为int:s-other
    s.compare(string_value)
    s.compare(size_type_index, size_type_count, string_value)
    s.compare(size_type_index1, size_type_count1, string_value,
            size_type_index2, size_type_count2)
    //
    s.compare(c_string_value)
    s.compare(size_type_index, size_type_count, c_string_value)
    s.compare(size_type_index, size_type_count1,
            c_string_value, size_type_count2)
  • 其他函数
    s.swap(string_variable)
    //
    //以下三个非成员函数
    swap(string_variable1, string_variable2)
    //
    getline(inStream, string_variable)
    // string结果不包含delimiter
    getline(inStream, string_variable, char_delimiter_value)

转载请注明作者:Focustc,博客地址为http://blog.csdn.net/caozhk,原文链接为点我

时间: 2024-10-25 11:40:05

C++中的容器的相关文章

【转】C++中map容器的说明和使用技巧

C++中map容器提供一个键值对容器,map与multimap差别仅仅在于multiple允许一个键对应多个值. 一.map的说明    1   头文件   #include   <map>     2   定义   map<string,   int>   my_Map;   或者是typedef     map<string,   int>   MY_MAP;   MY_MAP   my_Map;     3   插入数据   (1)   my_Map["

初识Java中的容器

记得第一次听到java中的容器是一个师哥说的,当时听着十分神秘.那么今天就来揭开那层神秘的面纱. 首先什么是容器呢? 在书写程序的时候,我们常常需要对大量的对象引用进行管理.为了实现有效的归类管理,我们常常将同类的引用放置在同一数据容器中.由于数据容器中存放了我们随时可能需要使用到的对象引用,所以一般的数据容器要都要能能提供方便的查询.遍历.修改等基本接口功能. 早期的OOP语言都通过数组的方式来实现对引用集的集中管理和维护. 但是数组方式下,数组大小需要提前被确定,并不允许修改大小,导致其作为

理解Docker(6):若干企业生产环境中的容器网络方案

本系列文章将介绍 Docker的相关知识: (1)Docker 安装及基本用法 (2)Docker 镜像 (3)Docker 容器的隔离性 - 使用 Linux namespace 隔离容器的运行环境 (4)Docker 容器的隔离性 - 使用 cgroups 限制容器使用的资源 (5)Docker 网络 (6)若干企业生产环境中的容器网络方案 Docker 在早期只有单机上的网络解决方案,在 1.19 版本引入了原生的 overlay 网络解决方案,但是它的性能损耗较大,可能无法适应一些生产环

在libvirt 中体验容器

libvirt是一个通用的虚拟化框架,支持xen,kvm,lxc多种虚拟化技术,本文作为一个笔记. 设置LXC为默认(默认为qemu) export LIBVIRT_DEFAULT_URI=lxc:/// virsh -c lxc:/// 可省略 网络设置 NAT NAT是libvirt默认自带,叫做default,通过下面的 命令查看 virsh net-list 假设宿主机有两个网卡,eth0为内网,eth1为外网,我们可以为容器桥接出两个接口: #cat lan.xml <network>

STL中的容器

STL中的容器 一. 种类: 标准STL序列容器:vector.string.deque和list. 标准STL关联容器:set.multiset.map和multimap. 非标准序列容器slist和rope.slist是一个单向链表,rope本质上是一个重型字符串 非标准关联容器hash_set.hash_multiset.hash_map和hash_multimap. 几种标准非STL容器,包括数组.bitset.valarray.stack.queue和priority_queue 值得

java中的容器解释

解释一:容器(Container)Spring 提供容器功能,容器可以管理对象的生命周期.对象与对象之间的依赖关系,您可以使用一个配置文件(通常是XML),在上面定义好对象的名称.如何产生(Prototype 方式或Singleton 方式).哪个对象产生之后必须设定成为某个对象的属性等,在启动容器之后,所有的对象都可以直接取用,不用编写任何一行程序代码来产生对象,或是建立对象与对象之间的依赖关系.换个更直白点的说明方式:容器是一个Java 所编写的程序,原先必须自行编写程序以管理对象关系,现在

如何让不同主机中docker容器可以相互访问

我们都知道同一台主机中的docker容器可以相互访问,那么不同主机中的docker容器间是否可以相互访问呢?答案是可以的,解决思路是在主机中把另外主机上docker容器的网段加入到路由表中. 现有主机A 192.168.124.51,主机B 192.168.124.55,具体步骤如下: 修改一台主机docker容器使用的网段(默认是172.17.x.x),如何修改请看上一篇. 假设已经修改好docker网段,例如主机A中docker容器使用10.1.x.x网段,主机B中docker使用172.1

docker中的容器互联-linking系统

docker中的容器互联-linking系统docker有一个linking 系统可以连接多个容器.它会创建一对父子关系,父容器可以看到所选择的子容器的信息.1)容器的命名系统linking系统依据容器的名称来执行.当我们创建容器的时候,系统会随机分配一个名字.当然我们也可以自己来命名容器,这样做有2个好处:• 当我们自己指定名称的时候,比较好记,比如一个web应用我们可以给它起名叫web• 当我们要连接其他容器时候,可以作为一个有用的参考点,比如连接web容器到db容器使用--name标记可以

XWork中的容器1

本文是<<struts2 技术内幕>>的学习笔记 在进行面向对象编程的时候,我们不可避免地要使用继承实现等等java提供的语法支持.但是复杂的对象关系也为对象生命周期的管理带来了至少以下两个问题. 1 程序运行时,应如何双肩我们所需要的对象. 2 当创建一个对象后,如何保证与其相关联的依赖关系也正确的被创建处理. 好在先辈们已经给我们想好了出路------在程序中引入一个额外的编程元素:容器(Container) 对象的生命管理周期 首先我们得引入一个概念-----控制反转(Inv