zoukankan      html  css  js  c++  java
  • C++容器常用方法简单总结

    共同方法

    顺序容器

    关联容器

    iterator

    迭代器

    const_iterator

    const迭代器

    value_type

    元素类型

    reference

    元素左值类型,意同value_type&

    const_reference

    const元素左值类型

    构造函数

    C c

    1. 只有顺序容器的构造函数能接受大小参数n

    C seq(n)

    C seq(n, t)  //包含nt

    1. 用一个容器初始化另一个容器时容器类型和元素类型都必须相同!但范围初始化时可以不同(只要元素能相互转换)eg:
      vector<const char*> ar = {“a”, “ab”};

    forward_list<string> br(ar.begin(), ar.end());

    1. 特有的类型:

    key_type

    value_type // set: key_type一样,

    map: pair<const k,v>,注意这个const
    map_type  //只有map才有,即v

    eg:

    map<string, int>::value_type v3;

    1. 注意虽然set的迭代器类型为分为iterator, const_iterator,但实际上两者都是只读类型!

    (所以一般关联容器都不用泛型算法,原因之一:多数泛型算法都要向元素写值,P383)

    C c1(c2)

    C c(b, e)

    C c{a,b,c,...}

    C c = {a,b,c,...}

    赋值与交换

    c1 = c2

    1. 特有的函数:
      seq.assign(b, e)  //seq的所有元素替换为迭代器b,e范围中的元素(不用管seq原来有多少元素)

    seq.assign(il)  //全部替换为初始化列表il

    seq.assgin(n, t)  // 全部替换为nt

    c1 = {a,b,c}

    a.swap(b)

    swap(a, b)

    大小:  c.size(); c.empty()

    /删元素

    c.insert()

    1. 特有的函数:

    c.push_back(t)  //返回void(forward_list不支持)

    c.emplace_back(args)

    c.push_front(t)  //vector, string不支持

    c.emplace_front(t)

    2. insert的用法(需要指明插入位置p)

    c.insert(p, t)  //在迭代器p前插入t,返回指向第一个新插入的值的迭代器

    c.insert(p, n, t)  //插入nt

    c.insert(p, b, e)

    c.insert(p, il)

    c.at(n)  // 返回下标为n的元素引用

    emplace也一样:c.emplace(p, args)

    3. 删除方法:

    c.pop_back()  // forward_list不支持

    c.pop_front()  //vector, string不支持

    c.erase(p); c.erase(b, e) //返回指向被删元素之后的元素的迭代器,注意不删e(此外还有泛型算法的erase

    1. 区别于顺序容器,insert不用指定插入位置(因为相对于无序容器他们本来就是有序的,会自动插入到正确的位置),对于mapset,只有当元素key不在c中时才会插入!所以为了同只插入是否成功,它要返回一个bool值来表示插入是否成功(无论是否插入成功都返回一个pair<iter, bool>,前者为指向该元素 的迭代器,后者为是否插入成功的bool值)

    c.insert(v)  //vvalue_type对象

    eg: word.insert(make_pair(a, b))

    上面插入单个元素insert会返回一个pair,但下面2种方法插入多个元素时,insert返回void(因为插入的元素会在c中重新排序,散落在不同的位置)

    c.insert(b, e) //对于mapset只插入key不在c中 的元素

    c.insert(il)

    c.emplace(args)

    2. 删除:

    c.erase(k)  // 删除每个关键字为k的元素,返回一个size_type类型的值:被删除的元素的数量

    c.erase(p)  // 删除迭代器p指定的元素,返回指向p之后的元素的迭代器

    c.erase(b, e)  //返回e

    取下标操作:c[k] //返回关键字为k 的元素的引用(注意!如果k不在c中,则会添加一个关键字为k的元素!)

    c.at(k)  // 访问关键字为k的元素,若k不在c中,抛出一个out_of_range异常

    3. 所以我们如果要判断一个元素是否在容器中,最好使用find:

    c.find(k)  //如果kc中,返回指向k的迭代器,否则返回的迭代器指向c.end()

    c.count(k)  //统计有多少个kc

    c.emplace()

    c.erase()

    c.clear()

    string提供的其他方法:

    1. 除了迭代器版本的构造函数、增/删函数外,string还提供接收下标版本的函数(由下标来指明位置,而不是迭代器)

    构造函数:

    string s(n, c)  //n个c字符

    string s(cp, n)  // cp是一个指向字符数组的c指针(或数组名/c字符串名),用该数组中的前n个字符初始化scp至少要包含n个字符)

    string s(s2, pos2)  //注意pos2是下标,从string s2[pos2]开始到末尾来拷贝初始化s (pos2 < s2.size()否则抛出异常)注意s2cp的区别!!如果是c指针(cp)则是拷贝前n个字符,如果是string(s2)则是用从pos2开始的后面的字符来进行初始化,npos一个是个数一个是下标

    string s(s2, pos2, len2)  //s2[pos2]开始拷贝len2个字符来初始化s (不管len2多长,最多只拷贝到s2结尾)

    eg:

    const char * cp = “hello world!!!”;

    char noNull[] = {‘H’, ‘i’};

    string s1(cp);  // s1 == “hello world!!!”

    string s2(noNull, 2);  // s2 == “Hi”

    string s3(noNull);  // 异常!如果noNull不是以’’为最后一个字符,则必须像s2那样传入一个长度参数来确定要拷贝的长度!

    string s4(cp + 6, 5);  // s4 == “world”

    string s5(s1, 6, 5);  // s5 == “world”

    string s6(s1, 6);  // s6 == “world!!!”

    string s7(s1, 6, 20);  // s7 == “world!!!” (最多只拷贝到末尾)

    string s8(s1, 16);  // 抛出out of range异常

    substr操作

    s1 = s.substr(pos1)  //s[pos1]开始拷贝到末尾(pos1 < s.size()

    s1 = s.substr(pos, n)  // s[pos]开始拷贝n个字符(pos默认为0,n默认为s.size()-pos,即默认拷贝所有字符)

    /删元素方法:

    s.insert(pos, args)  //在pos插入args指定的字符(pos可以是下标或迭代器,如果是下标则返回指向s的引用)

    s.erase(pos, len)  //删除pos开始的len个字符(如果没有len则删掉pos后面所有的字符),返回指向s的引用

    s.assign(args)  //将s中的字符替换为args指定的字符,返回指向s的引用

    s.append(args)  //将args追加到s,返回指向s的引用

    s.replace(range, args)  //替换range中的字符为args(range可以是下标+长度或者一对迭代器),返回指向s的引用

    上面的args可以是:

    str       

    str, pos, len

    cp, len

    n, c  //n个c字符

    b, e

    初始化列表

    s.insert(s.size(), 5, !)  //s尾部插入5个!号

    s.erase(s.size() - 5, 5)  //删除s最后5个字符

    接受c风格数组/字符串的insert/assign版本:

    const char *cp = “stately, plump buck”

    s.assign(cp, 7)  // s==”stately”

    s.insert(s.size(), cp+7)  // s==”stately, plump buck”

    string的搜索函数(如果没找到,则返回string::npos)、数值转换、compare函数(p325-328)

    s.find(args)   //找args第一次出现的位置   (第一个字符位置为0,如:string name = "AnnaBelle"; auto pos1 = name.find("Ann"); //pos1=0)

    s.rfind(args)   //找args最后一次出现的位置

    s.find_first_of(args)   //找args中任何一个字符第一次出现的位置

    s.find_last_of(args)   //找args中任何一个字符最后一次出现的位置

    s.find_first_not_of(args)   //找第一个不在args中的字符

    s.find_last_not_of(args)   //找最后一个不在args中的字符

    args是以下形式之一:

    c, pos     //从s中位置pos开始查找字符c,pos默认值为0

    s2, pos    //从s中位置pos开始查找字符串s2,pos默认值为0

    cp, pos     //从s中位置pos开始查找指针cp指向的一空字符结尾的C风格字符串,pos默认值为0

    cp, pos, n    //从s中位置pos开始查找指针cp指向的数组的前n个字符。pos和n无默认值

    string的比较函数(两个string相同返回0,左边大于右边返回正数,反之负数)(此外,C库函数strcmp也可)

    s.compare(args)

    args是以下形式之一:

    s2                                           比较s,s2

    pos1, n1, s2                           将s从pos1开始的n1个字符与s2比较

    pos1, n1, s2, pos2, n2          将s从pos1开始的n1个字符与s2中从pos2开始的n2个字符比较

    cp                                          将s与cp指向的以空字符结尾的字符数组比较

    pos1, n1, cp                          将s从pos1开始的n1个字符与cp指向的以空字符结尾的字符数组比较

    pos1, n1, cp, n2                    将s从pos1开始的n1个字符与cp指向的地址开始的n2个字符比较

    数值转换函数(还有一个比较土的方法,使用 stringstream 对象写入再写出(注意写出后要对对象进行clear操作))

    to_string(val)                        返回数值val的string表示(浮点型也可以转)

    stoi(s, p, b)                           返回s的起始子串的数值,p是size_t指针,用来保存s中第一个非数值字符的下标默认为0,b表示转为几进制(默认为10,即默认转为十进制数)(一般p和b都不用管)

    stol(s, p, b)                             例如: double s = 3.14; string ss = to_string(s);  // ss = "3.140000"

    stoul(s, p, b)                                       string a = "3.14"; int aa = stoi(a);   //aa = 3

    stoll(s, p, b)

    stoull(s, p, b)

    stof(s, p)

    stod(s, p)

    stold(s, p)

    容器适配器:stackqueuepriority_queue

    size_type

    value_type

    container_type

    A a;

    A a(c);

    a.empty()

    a.size()

    swap(a, b)

    a.swap(b)

    stack操作:

    s.pop()  //删除栈顶元素(注意不返回该元素!)

    s.push(item)  //将item压入栈

    s.emplace(args)  //同上(itemargs构造)

    s.top()  //返回栈顶元素(注意不弹出元素!)

    queue, priority_queue操作:

    q.pop()

    q.front()

    q.back()

    q.top()  //最高优先级元素(仅priority_queue有)

    q.push(item)

    q.emplace(args)

  • 相关阅读:
    SCAU 9504 面试
    SCAU 9503 懒人选座位
    SCAU 8628 相亲
    SCAU 10691 ACM 光环
    SCAU 8626 原子量计数
    SCAU 10674 等差对
    HDU ACM 1048 The Hardest Problem Ever (水题)
    SCAU 9502 ARDF
    SCAU 10686 DeathGod不知道的事情
    SCAU 8629 热身游戏(高精度)
  • 原文地址:https://www.cnblogs.com/tan-wm/p/14359989.html
Copyright © 2011-2022 走看看