C++ STL容器操作：6种常用场景算法

最新推荐文章于 2024-10-06 14:42:09 发布
最新推荐文章于 2024-10-06 14:42:09 发布
阅读量375 收藏 6
点赞数 3
文章标签： c++ 算法 开发语言
学习分享，微信公众号 “开源519”
本文链接：https://blog.csdn.net/qq_38750572/article/details/142666387
版权

C++ STL容器操作：6种常用场景算法

[TOC]

引言

  在日常软件开发工作中，容器操作如查找、排序、和元素替换等任务极为常见。幸运的是，C++的标准化利器——STL(Standard Template Library，标准模板库)为我们封装了一系列高效且灵活的算法，极大简化了这些操作。特别是自C++11版本以来，STL引入了一批新晋的通用算法，它们不仅功能强大，而且设计得更加人性化，旨在进一步提升我们的编码效率与程序性能。本文列举一些常用到的方法，便于日后回顾和查阅。

概述

  日常开发中的容器操作，如查找、删除、排序、分割、拷贝和合并，均可借助STL中的精选算法高效完成。本文将概览这些核心STL算法，助力开发流程优化。

查找与计数

std::find

  • 作用： 找容器中第一个匹配给定值的元素
  • 示例
vector<std::string> testArrgs = {"XiaoFang", "LiHua", "XiaoMing", "XiaoMing", "XiaoHong", "JianGuo", "XiaoFangFang", "XiaoMing"};
    DumpVector("testArrgs", testArrgs);

    auto find = std::find(testArrgs.begin(), testArrgs.end(), "XiaoMing");
    if (find != testArrgs.end()) {
        SPR_LOGD("find: dest = \"XiaoMing\", result = %s, index = %ld\n", find->c_str(), find - testArrgs.begin());
    }
  • 结果
D: find: dest = "XiaoMing", result = XiaoMing, index = 2

std::find_if

  • 作用： 查找容器中第一个满足谓词条件的元素
  • 示例
vector<std::string> testArrgs = {"XiaoFang", "LiHua", "XiaoMing", "XiaoMing", "XiaoHong", "JianGuo", "XiaoFangFang", "XiaoMing"};
    
    auto findIf = std::find_if(testArrgs.begin(), testArrgs.end(),  [](const std::string &str) { return str.find("Ming") != std::string::npos; });
    if (findIf != testArrgs.end()) {
        SPR_LOGD("find_if: dest = \"Ming\", result = %s, index = %ld\n", findIf->c_str(), findIf - testArrgs.begin());
    }

③ 结果

D: find_if: dest = "Ming", result = XiaoMing, index = 2

std::find_if_not

  • 作用： 寻找第一个不符合指定条件的元素
  • 示例
vector<std::string> testArrgs = {"XiaoFang", "LiHua", "XiaoMing", "XiaoMing", "XiaoHong", "JianGuo", "XiaoFangFang", "XiaoMing"};

    auto findIfNot = std::find_if_not(testArrgs.begin(), testArrgs.end(),  [](const std::string &str) { return str.find("Xiao") != std::string::npos; });
    if (findIfNot != testArrgs.end()) {
        SPR_LOGD("find_if_not: dest = \"Xiao\", result = %s, index = %ld\n", findIfNot->c_str(), findIfNot - testArrgs.begin());
    }
  • 结果
D: find_if_not: dest = "Xiao", result = LiHua, index = 1

std::find_end

  • 作用： 查找一个子序列最后一次出现的位置
  • 示例
vector<std::string> testArrgs = {"XiaoFang", "LiHua", "XiaoMing", "XiaoMing", "XiaoHong", "JianGuo", "XiaoFangFang", "XiaoMing"};

    vector<std::string> subArrgs1 = {"XiaoMing", "XiaoHong"};
    auto findEnd = std::find_end(testArrgs.begin(), testArrgs.end(), subArrgs1.begin(), subArrgs1.end());
    if (findEnd != testArrgs.end()) {
        SPR_LOGD("find_end: dest = {\"XiaoMing\", \"XiaoHong\"}, result = %s, index = %ld\n", findEnd->c_str(), findEnd - testArrgs.begin());
    }
  • 结果
D: find_end: dest = {"XiaoMing", "XiaoHong"}, result = XiaoMing, index = 3

std::find_first_of

  • 作用： 查找序列中任何一个元素首次出现的位置
  • 示例
vector<std::string> testArrgs = {"XiaoFang", "LiHua", "XiaoMing", "XiaoMing", "XiaoHong", "JianGuo", "XiaoFangFang", "XiaoMing"};

    vector<std::string> subArrgs2 = {"JianGuo"};
    auto findFirstOf = std::find_first_of(testArrgs.begin(), testArrgs.end(), subArrgs2.begin(), subArrgs2.end());
    if (findFirstOf != testArrgs.end()) {
        SPR_LOGD("find_first_of: dest = {\"JianGuo\"}, result = %s, index = %ld\n", findFirstOf->c_str(), findFirstOf - testArrgs.begin());
    }
  • 结果
D: find_first_of: dest = {"JianGuo"}, result = JianGuo, index = 5

std::adjacent_find

  • 作用： 查找相邻重复的元素
  • 示例
vector<std::string> testArrgs = {"XiaoFang", "LiHua", "XiaoMing", "XiaoMing", "XiaoHong", "JianGuo", "XiaoFangFang", "XiaoMing"};

    auto adjacentFind = std::adjacent_find(testArrgs.begin(), testArrgs.end(), [](const std::string &str1, const std::string &str2) { return str1 == str2; });
    if (adjacentFind != testArrgs.end()) {
        SPR_LOGD("adjacent_find: result = %s, index = %ld\n", adjacentFind->c_str(), adjacentFind - testArrgs.begin());
    }
  • 结果
D: adjacent_find: result = XiaoMing, index = 2

std::count

  • 作用： 计算容器中指定值出现的次数
  • 示例
vector<std::string> testArrgs = {"XiaoFang", "LiHua", "XiaoMing", "XiaoMing", "XiaoHong", "JianGuo", "XiaoFangFang", "XiaoMing"};

    auto cnt = std::count(testArrgs.begin(), testArrgs.end(), "XiaoFang");
    if (cnt > 0) {
        SPR_LOGD("count: dest = \"XiaoFang\", result = %ld\n", cnt);
    }
  • 结果
D: count: dest = "XiaoFang", result = 1

std::count_if

  • 作用： 计算满足谓词条件的元素数量
  • 示例
vector<std::string> testArrgs = {"XiaoFang", "LiHua", "XiaoMing", "XiaoMing", "XiaoHong", "JianGuo", "XiaoFangFang", "XiaoMing"};
    
    auto cntIf = std::count_if(testArrgs.begin(), testArrgs.end(), [](const std::string &str) { return str.find("Xiao") != std::string::npos; });
    if (cntIf > 0) {
        SPR_LOGD("count_if: dest = \"Xiao\", result = %ld\n", cntIf);
    }
  • 结果
D: count_if: dest = "Xiao", result = 6

移除与替换

std::remove

  • 作用： 重新排列容器元素，使得所有不匹配特定值的元素被放置在容器的前端。配合earse实现移除不匹配元素。
  • 示例
vector<std::string> testArrgs = {"XiaoFang", "LiHua", "XiaoMing", "XiaoMing", "XiaoHong", "JianGuo", "XiaoFangFang", "XiaoMing"};

    vector<std::string> rmArrgs(testArrgs);
    auto remove = std::remove(rmArrgs.begin(), rmArrgs.end(), "XiaoMing");
    if (remove != rmArrgs.end()) {
        rmArrgs.erase(remove, rmArrgs.end());
        DumpVector("rmArrgs", rmArrgs);
    }
  • 结果
D: rmArrgs: "XiaoFang", "LiHua", "XiaoHong", "JianGuo", "XiaoFangFang",

std::remove_if

  • 作用： 重新排列容器元素，使得所有不满足谓词条件的元素被放置在容器的前端。配合earse实现移除不匹配元素。
  • 示例
vector<std::string> testArrgs = {"XiaoFang", "LiHua", "XiaoMing", "XiaoMing", "XiaoHong", "JianGuo", "XiaoFangFang", "XiaoMing"};
    
    vector<std::string> rmIfArrgs(testArrgs);
    auto removeIf = std::remove_if(rmIfArrgs.begin(), rmIfArrgs.end(), [](const std::string &str) { return str.find("Xiao") != std::string::npos; });
    if (removeIf != rmIfArrgs.end()) {
        rmIfArrgs.erase(removeIf, rmIfArrgs.end());
        DumpVector("rmArrgs", rmArrgs);
    }
  • 结果
D: rmIfArrgs: "XiaoFang", "LiHua", "XiaoHong", "JianGuo", "XiaoFangFang"

std::remove_copy

  • 作用： 从源序列拷贝元素到目标序列，排除满足条件的元素。
  • 示例
vector<std::string> testArrgs = {"XiaoFang", "LiHua", "XiaoMing", "XiaoMing", "XiaoHong", "JianGuo", "XiaoFangFang", "XiaoMing"};
    
    vector<std::string> dstArrgs;
    vector<std::string> rcArrgs(testArrgs);
    std::remove_copy(rcArrgs.begin(), rcArrgs.end(), std::back_inserter(dstArrgs), "XiaoMing");
    DumpVector("dstArrgs", dstArrgs);
  • 结果
D: dstArrgs: "XiaoFang", "LiHua", "XiaoHong", "JianGuo", "XiaoFangFang"

std::replace

  • 作用： 将所有出现的指定元素替换为新值。
  • 示例
vector<std::string> testArrgs = {"XiaoFang", "LiHua", "XiaoMing", "XiaoMing", "XiaoHong", "JianGuo", "XiaoFangFang", "XiaoMing"};
    
    vector<std::string> rpArrgs(testArrgs);
    std::replace(rpArrgs.begin(), rpArrgs.end(), "XiaoMing", "MingMing");
    DumpVector("rpArrgs", rpArrgs);
  • 结果
D: rpArrgs: "XiaoFang", "LiHua", "MingMing", "MingMing", "XiaoHong", "JianGuo", "XiaoFangFang", "MingMing",

std::replace_if

  • 作用： 满足谓词条件的元素，替换为指定的替换值。
  • 示例
vector<std::string> testArrgs = {"XiaoFang", "LiHua", "XiaoMing", "XiaoMing", "XiaoHong", "JianGuo", "XiaoFangFang", "XiaoMing"};
    
    vector<std::string> rpIfArrgs(testArrgs);
    std::replace_if(rpIfArrgs.begin(), rpIfArrgs.end(), [](const std::string &str) { return (str == "XiaoFang"); }, "FangFang");
    DumpVector("rpIfArrgs", rpIfArrgs);
  • 结果
D: rpIfArrgs: "FangFang", "LiHua", "XiaoMing", "XiaoMing", "XiaoHong", "JianGuo", "XiaoFangFang", "XiaoMing",

std::replace_copy

  • 作用：用于在指定范围内将所有匹配某个值的元素替换为另一个值，拷贝到另一个的容器中。
  • 示例
vector<std::string> testArrgs = {"XiaoFang", "LiHua", "XiaoMing", "XiaoMing", "XiaoHong", "JianGuo", "XiaoFangFang", "XiaoMing"};
    
    vector<std::string> rpCpDstArrgs;
    vector<std::string> rpCopyArrgs(testArrgs);
    std::replace_copy(rpCopyArrgs.begin(), rpCopyArrgs.end(), std::back_inserter(rpCpDstArrgs), "XiaoMing", "MingMing");
    DumpVector("rpCpDstArrgs", rpCpDstArrgs);
  • 结果
D: rpCpDstArrgs: "XiaoFang", "LiHua", "MingMing", "MingMing", "XiaoHong", "JianGuo", "XiaoFangFang", "MingMing"

std::swap

  • 作用：交换两个变量的值。
  • 示例
vector<std::string> testArrgs = {"XiaoFang", "LiHua", "XiaoMing", "XiaoMing", "XiaoHong", "JianGuo", "XiaoFangFang", "XiaoMing"};
    
    vector<std::string> swapSrcArrgs(testArrgs);
    vector<std::string> swapDstArrgs = {"Vince Carter", "Rose", "James"};
    std::swap(swapSrcArrgs, swapDstArrgs);
    DumpVector("swapSrcArrgs", swapSrcArrgs);
    DumpVector("swapDstArrgs", swapDstArrgs);
  • 结果
D: swapSrcArrgs: "Vince Carter", "Rose", "James", 
  D: swapDstArrgs: "XiaoFang", "LiHua", "XiaoMing", "XiaoMing", "XiaoHong", "JianGuo", "XiaoFangFang", "XiaoMing",

排序与组织

std::sort

  • 作用：对容器元素进行排序。
  • 示例
vector<std::string> testArrgs = {"XiaoFang", "LiHua", "XiaoMing", "XiaoMing", "XiaoHong", "JianGuo", "XiaoFangFang", "XiaoMing"};

    // sort
    vector<std::string> sortArrgs(testArrgs);
    std::sort(sortArrgs.begin(), sortArrgs.end());
    DumpVector("sortArrgs", sortArrgs);
    std::sort(sortArrgs.begin(), sortArrgs.end(), [](const std::string &str1, const std::string &str2) { return str1.size() > str2.size(); });
    DumpVector("sortArrgs", sortArrgs);
  • 结果
D: sortArrgs: "JianGuo", "LiHua", "XiaoFang", "XiaoFangFang", "XiaoHong", "XiaoMing", "XiaoMing", "XiaoMing", 
  D: sortArrgs: "XiaoFangFang", "XiaoFang", "XiaoHong", "XiaoMing", "XiaoMing", "XiaoMing", "JianGuo", "LiHua",

std::stable_sort

  • 作用：稳定排序，保持相等元素的原有顺序。
  • 示例
// stable_sort
    vector<Persion> srcPersions = {{"LiWei", 18}, {"LiHua", 20}, {"ZhangLei", 19}, {"WeiGuo", 19}, {"ZhenHua", 20}, {"JianGuo", 18}, {"ZhiGuo", 19}, {"JianHua", 19}};
    vector<Persion> sPersions(srcPersions);
    std::stable_sort(sPersions.begin(), sPersions.end(), [](const Persion &p1, const Persion &p2) { return p1.age > p2.age; });
    DumpVector("sPersions", sPersions);
    std::stable_sort(sPersions.begin(), sPersions.end(), [](const Persion &p1, const Persion &p2) { return p1.age < p2.age; });
    DumpVector("sPersions", sPersions);
  • 结果
D: sPersions = { {"LiHua", 20}, {"ZhenHua", 20}, {"ZhangLei", 19}, {"WeiGuo", 19}, {"ZhiGuo", 19}, {"JianHua", 19}, {"LiWei", 18}, {"JianGuo", 18}, }
  D: sPersions = { {"LiWei", 18}, {"JianGuo", 18}, {"ZhangLei", 19}, {"WeiGuo", 19}, {"ZhiGuo", 19}, {"JianHua", 19}, {"LiHua", 20}, {"ZhenHua", 20}, }

std::partial_sort

  • 作用：对部分区间排序。
  • 示例
vector<Persion> srcPersions = {{"LiWei", 18}, {"LiHua", 20}, {"ZhangLei", 19}, {"WeiGuo", 19}, {"ZhenHua", 20}, {"JianGuo", 18}, {"ZhiGuo", 19}, {"JianHua", 19}};

    // partial_sort
    vector<Persion> prtPersions(srcPersions);
    vector<Persion> sortPersions(srcPersions);
    std::partial_sort(prtPersions.begin(), prtPersions.begin() + 5, prtPersions.end(), [](const Persion &p1, const Persion &p2) { return p1.age > p2.age; });
    std::sort(sortPersions.begin(), sortPersions.begin() + 5, [](const Persion &p1, const Persion &p2) { return p1.age > p2.age; });
    DumpVector("prtPersions", prtPersions);
    DumpVector("sortPersions", sortPersions);
  • 结果
D: prtPersions = { {"ZhenHua", 20}, {"LiHua", 20}, {"WeiGuo", 19}, {"ZhiGuo", 19}, {"ZhangLei", 19}, {"JianGuo", 18}, {"LiWei", 18}, {"JianHua", 19}, }
  D: sortPersions = { {"LiHua", 20}, {"ZhenHua", 20}, {"ZhangLei", 19}, {"WeiGuo", 19}, {"LiWei", 18}, {"JianGuo", 18}, {"ZhiGuo", 19}, {"JianHua", 19}, }

std::reverse

  • 作用：对部分区间排序。
  • 示例
vector<Persion> srcPersions = {{"LiWei", 18}, {"LiHua", 20}, {"ZhangLei", 19}, {"WeiGuo", 19}, {"ZhenHua", 20}, {"JianGuo", 18}, {"ZhiGuo", 19}, {"JianHua", 19}};

    // reverse
    vector<Persion> rPersions(srcPersions);
    std::reverse(rPersions.begin(), rPersions.end());
    DumpVector("rPersions", rPersions);
  • 结果
D: rPersions = { {"JianHua", 19}, {"ZhiGuo", 19}, {"JianGuo", 18}, {"ZhenHua", 20}, {"WeiGuo", 19}, {"ZhangLei", 19}, {"LiHua", 20}, {"LiWei", 18}, }

std::rotate

  • 作用：对部分区间排序。
  • 示例
vector<Persion> srcPersions = {{"LiWei", 18}, {"LiHua", 20}, {"ZhangLei", 19}, {"WeiGuo", 19}, {"ZhenHua", 20}, {"JianGuo", 18}, {"ZhiGuo", 19}, {"JianHua", 19}};

    // rotate
    vector<Persion> rtPersions(srcPersions);
    std::rotate(rtPersions.begin(), rtPersions.begin() + 3, rtPersions.end());
    DumpVector("rtPersions", rtPersions);
  • 结果
D: rPersions = { {"JianHua", 19}, {"ZhiGuo", 19}, {"JianGuo", 18}, {"ZhenHua", 20}, {"WeiGuo", 19}, {"ZhangLei", 19}, {"LiHua", 20}, {"LiWei", 18}, }

分割

std::partition

  • 作用：分割容器，使满足谓词的元素在前，不满足的在后。
  • 示例
vector<std::string> testArrgs = {"LiHua", "ZhangHong", "HeDa", "LiWei", "ZhangLei", "WeiGuo", "ZhenHua"};

    // partition
    vector<std::string> partArrgs(testArrgs);
    std::partition(partArrgs.begin(), partArrgs.end(), [](const std::string& str) { return (str.compare(0, 5, "Zhang") == 0); });
    DumpVector("partArrgs", partArrgs);
  • 结果
D: partArrgs: "ZhangLei", "ZhangHong", "HeDa", "LiWei", "LiHua", "WeiGuo", "ZhenHua",

std::stable_partition

  • 作用：类似partition，但保持相同元素的相对顺序不变。
  • 示例
vector<std::string> testArrgs = {"LiHua", "ZhangHong", "HeDa", "LiWei", "ZhangLei", "WeiGuo", "ZhenHua"};

    // stable_partition
    vector<std::string> stPartArrgs(testArrgs);
    std::stable_partition(stPartArrgs.begin(), stPartArrgs.end(), [](const std::string& str) { return (str.compare(0, 5, "Zhang") == 0); });
    DumpVector("stPartArrgs", stPartArrgs);
  • 结果
D: stPartArrgs: "ZhangHong", "ZhangLei", "LiHua", "HeDa", "LiWei", "WeiGuo", "ZhenHua",

拷贝与生成

std::copy

  • 作用：拷贝容器或范围内的元素到另一位置。
  • 示例
vector<std::string> srcArrgs = {"LiHua", "ZhangHong", "HeDa", "LiWei", "ZhangLei", "WeiGuo", "ZhenHua"};

    // copy
    vector<std::string> dstCopyArrgs;
    std::copy(srcArrgs.begin(), srcArrgs.end(), std::back_inserter(dstCopyArrgs));
    DumpVector("dstCopyArrgs", dstCopyArrgs);
  • 结果
D: dstCopyArrgs: "LiHua", "ZhangHong", "HeDa", "LiWei", "ZhangLei", "WeiGuo", "ZhenHua",

std::copy_if

  • 作用：根据谓词条件拷贝元素。
  • 示例
vector<std::string> srcArrgs = {"LiHua", "ZhangHong", "HeDa", "LiWei", "ZhangLei", "WeiGuo", "ZhenHua"};

    // copy_if
    vector<std::string> dstCopyIfArrgs;
    std::copy_if(srcArrgs.begin(), srcArrgs.end(), std::back_inserter(dstCopyIfArrgs), [](const std::string& str) { return (str.compare(0, 5, "Zhang") == 0); });
    DumpVector("dstCopyIfArrgs", dstCopyIfArrgs);
  • 结果
D: dstCopyIfArrgs: "ZhangHong", "ZhangLei",

std::copy_n

  • 作用：拷贝指定数量的元素。
  • 示例
vector<std::string> srcArrgs = {"LiHua", "ZhangHong", "HeDa", "LiWei", "ZhangLei", "WeiGuo", "ZhenHua"};

    // copy_n
    vector<std::string> dstCopyNArrgs;
    std::copy_n(srcArrgs.begin(), 3, std::back_inserter(dstCopyNArrgs));
    DumpVector("dstCopyNArrgs", dstCopyNArrgs);
  • 结果
D: dstCopyNArrgs: "LiHua", "ZhangHong", "HeDa",

std::generate

  • 作用：使用生成器函数填充容器。
  • 示例
// generate
    vector<std::string> genArrgs(5);
    std::generate(genArrgs.begin(), genArrgs.end(), [](){ return "Hello"; });
    DumpVector("genArrgs", genArrgs);
  • 结果
D: genArrgs: "Hello", "Hello", "Hello", "Hello", "Hello",

std::generate_n

  • 作用：生成指定数量的元素填充容器。
  • 示例
// generate_n
    vector<std::string> genNArrgs;
    std::generate_n(std::back_inserter(genNArrgs), 3, [](){ return "Hello"; });
    DumpVector("genNArrgs", genNArrgs);
  • 结果
D: genNArrgs: "Hello", "Hello", "Hello",

集合操作

std::merge

  • 作用：生成指定数量的元素填充容器。
  • 示例
vector<std::string> srcArrgs = {"Vince Carter", "Rose", "James"};

    // merge
    vector<std::string> mergeArrgs;
    vector<std::string> tmpArrgs = {"Irving"};
    std::merge(srcArrgs.begin(), srcArrgs.end(), tmpArrgs.begin(), tmpArrgs.end(), std::back_inserter(mergeArrgs));
    DumpVector("mergeArrgs", mergeArrgs);
  • 结果
D: mergeArrgs: "Irving", "Vince Carter", "Rose", "James",

std::inplace_merge

  • 作用：就地归并两个有序范围。
  • 示例
vector<std::string> srcArrgs = {"Vince Carter", "Rose", "James"};

    // inplace_merge
    vector<std::string> inplaceMergeArrgs(srcArrgs);
    std::inplace_merge(inplaceMergeArrgs.begin(), inplaceMergeArrgs.begin() + 2, inplaceMergeArrgs.end());
    DumpVector("inplaceMergeArrgs", inplaceMergeArrgs);
  • 结果
D: inplaceMergeArrgs: "James", "Vince Carter", "Rose",
拂去尘世尘
关注
C++ STL中的std::remove_if 的用法详解
程序员黄老师的精品课！
07-15 271
是C++ STL中头文件的一部分，它用于从容器中移除所有满足给定谓词（即判断条件）的元素。值得注意的是，并不会直接删除元素，而是将不满足条件的元素移到容器的前面，返回一个新的迭代器指向第一个应被删除的元素。因此，为了完全删除这些元素，我们需要配合容器的erase成员函数使用。假设我们有一个Student类，包含姓名、年龄和成绩等属性，我们的目标是从一个中移除所有成绩低于60分的学生。首先，定义Studentpublic:int score;// 用于输出学生信息int main()
C++标准模板库（STL）常见容器的用法
weixin_40537643的博客
09-04 872
STL常见容器的用法vector定义访问元素常见函数set定义访问元素常用函数string初始化访问元素常用函数 vector 特点：变长数组 使用vector，需要添加vector头文件，并写上using namespace std; 其他容器类似，都需要添加相应的头文件，不再赘述。 定义 vector<typename> name; typename可以是任何基本类型，也可以是S...
C++：常用stl容器及其操作
qq_73176808的博客
07-22 855
本文介绍C++常用stl容器及操作
stl clocklist 查找元素_C++ STL 常用算法总结
weixin_39856265的博客
11-27 281
一、概述 STL算法部分主要由头文件,,组成。要使用 STL中的算法函数必须包含头文件 ，对于数值算法须包含 ， 中则定义了一些模板类，用来声明函数对象。二、常用算法介绍STL 中算法大致分为四类：非可变序列算法：指不直接修改其所操作的容器内容的算法。可变序列算法：指可以修改它们所操作的容器内容的算法。排序算法：包括对序列进行排序和合并的算法、搜索算法以及有序序列上的集...
C++ STL笔记一：初识STL；容器；算法；迭代器；容器装数据
xiaoyaolangwj的博客
02-01 1386
一：由来： 长久以来，软件界一直希望建立一种可重复利用的东西。 C++的面向对象和泛型编程思想，目的就是复用性的提升。 面向对象：三大特点： 封装：将事物共有的特性（共性）抽离出来，封装为一个类，基于类具体化实例。从而提高复用性。物以类聚。 继承：子类继承父类。把父类的东西（属性、行为）都拿过来，子类不用再次重新声明一遍。也提高了代码的复用性。 多态：一个函数名称，有多个实现方式。根据调用的对象不同，产生不同的结果。不同的子类实例赋值给父类变量，来实现多态。也提高了代码复用性。
深入探究C++中的STL：容器、迭代器与算法全解析
BXA
05-07 1687
本文主要介绍了C++ STL（Standard Template Library）中的三个核心组件：容器、迭代器和算法。容器是用于存储和管理数据的对象，包括vector、list、set、map等。而迭代器是容器的访问方式，用于遍历容器中的元素。最后介绍了STL算法的基本分类、应用场景以及性能优化技巧等。STL是C++编程中常用的重要部分掌握其知识对于提高程序开发效率和编程能力至关重要。
C++标准库：STL容器与算法详解
AI天才研究院
01-28 927
1.背景介绍 1. 背景介绍 C++标准库是C++程序设计中不可或缺的一部分，它提供了丰富的数据结构、算法和工具，帮助开发者更高效地编写程序。STL(Standard Template Library)是C++标准库中最重要的一部分，它提供了一系列模板类和模板函数，用于实现各种常用的数据结构和算法。 在本文中，我们将深入探讨STL容器和算法的相关概念、原理、实践和应用。我们将涵盖STL容器的...
C++中的STL：一些常用的STL容器和算法
算法大师！
07-10 542
STL（Standard Template Library）是C++中一个强大的库，用于处理数据结构。它提供了一系列预定义的工具，如算法、容器和迭代器，可以轻松地在程序中使用。STL的主要目标是提供一种灵活和高效的处理数据结构和算法的方式。它通过提供具有明确规则和模板的现成工具来实现这一目标。这意味着您可以在不担心性能问题的情况下，使用这些工具处理不同类型的数据。STL分为四个主要部分：算法、容器、函数和迭代器。算法是执行常见任务（如排序、搜索和操作项目集合）的函数。
STL std::accumulate()算法：元素的累加和
weixin_48979633的博客
02-23 1607
是 C++ 标准库中定义于 头文件的一个算法，用于计算给定范围 中所有元素的累加和，也可以在累加时应用一个自定义的二元操作。它提供了一种简便的方式来累积容器中的元素值，无论是进行简单的求和还是更复杂的累积操作。 提供了两种重载形式：不带自定义操作的重载： ：定义了一个输入范围的开始和结束迭代器， 是要累加的元素范围。 ：累加的初始值。 带自定义操作的重载： ：定义了一个输入范围的开始和结束迭代器， 是要累加的元素范围。 ：累加的初始值。 ：一个二元操作，用于代替加法操作。这个操作接受两个参数（
深入理解C++ STL库：数据结构与算法的最佳实现.md
09-04
最后，文章提供了性能优化的建议和最佳实践，强调了在不同场景下选择合适的容器和算法、避免不必要的资源消耗，以及如何利用C++17引入的并行算法提升程序性能。通过这篇文章，读者可以全面掌握STL的使用方法，并在...
深入解析C++ STL中的常用容器
09-05
本篇文章将深入解析C++ STL中的一些常用容器，包括顺序性容器、关联容器以及容器适配器。 1. 顺序性容器 - (1) vector `vector` 是一种动态数组，内存中存储是连续的，支持快速随机访问。但由于插入和删除操作...
STL.rar_C++ STL_STL_site:www.pudn.com_visual c
09-23
在"STL.doc"文档中，可能会详细介绍STL的各种容器的使用方法、迭代器的工作原理、常见算法的实现以及如何在Visual C++项目中集成STL。通过学习这部分内容，开发者不仅可以提升C++编程的效率，还能掌握面向对象编程和...
c++ STL容器总结之:vertor与list的应用
09-05
C++中的STL（Standard Template Library，标准模板库）是一个强大的工具集，它极大地提高了C++程序员的生产力。STL的核心组成部分包括...了解并熟练使用STL容器，能够帮助C++程序员编写出更高效、更易于维护的代码。
[c语言]一句话讲清循环中break和continue的作用与区别
2303_77060768的博客
09-29 160
1.两者的作用break和contuinue都只能在循环中使用，都用来停止循环。​​​​​​​2.两者的区别break在循环中只要遇到break，就直接永久终止当前循环，开始执行当前循环之外的代码。在循环中只要遇到continue，就结束本次循环，继续进行下一次循环。
【C语言】数据类型和变量
2302_76713442的博客
10-06 1011
一、数据类型分类（内置数据类型：字符型、整型、浮点型和布尔类型）（自定义数据类型：数组、结构体、枚举和联合体）二~三、深入研究内置数据类型（内置数据类型的大小、使用内置数据类型创建变量、signed 和 unsigned）四、自定义数据类型的内容过于庞大，所以每种自定义数据类型都专门写了一篇博客来介绍，文中有相应链接。
第 21 章 一条记录的多幅面孔——事务的隔离级别与 MVCC
weixin_45740473的博客
10-02 950
并发的事务在运行过程中会出现一些可能的引发一致性问题SQL 标准中有4种隔离级别版本链ReadView。
【C++力扣】917.仅仅反转字母|387.字符串中第一个唯一字符|415.字符串相加
最新发布
白乐天_ξ( ✿＞◡❛)的博客
10-06 424
本文写的是力扣三道题的解答：917、387、415题，都是与string字符串有关的！
C - Separated Lunch
m0_74304371的博客
10-05 234
C - Separated Lunch(KEYENCE Programming Contest 2024 (AtCoder Beginner Contest 374))
C++ STL Set容器详解：26种常用函数及应用
总结：C++的set容器在数据结构和算法方面提供了强大的支持，它维护了一个无重复且有序的元素集合，适用于多种应用场景。通过理解并掌握set的各种函数和特性，开发者可以有效地管理和操作这些集合，提高代码的效率和...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

拂去尘世尘

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

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

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

打赏作者

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

抵扣说明：

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

余额充值