经验首页 前端设计 程序设计 Java相关 移动开发 数据库/运维 软件/图像 大数据/云计算 其他经验
当前位置：技术经验 » 程序设计 » C++ » 查看文章
C++学习笔记之进阶编程 - time-flies
来源：cnblogs　　作者：time-flies　　时间：2021/6/15 9:19:41　　对本文有异议

目录

进阶编程

STL（Standard Template Library）

  • STL算法是泛型的（generic），不与任何特定数据结构和对象绑定，不必在环境类似的情况下重写代码；
  • STL算法可以量身定做，并且具有很高的效率；
  • STL可以进行扩充，可以编写自己的组件并且能与STL标准的组件进行很好的配合；

容器（container）

容器用于存放数据；STL的容器分为两大类：

  • 序列式容器（Sequence Containers）：其中的元素都是可排序的（ordered），STL提供了vector，list，deque等序列式容器，而stack，queue，priority queue则是容器适配器；
  1. struct Display
  2. {
  3.     void operator()(int i)
  4.     {
  5.         cout << i << " ";
  6.     }
  7. };
  9. int main()
  10. {
  11.     int iArr[] = { 1, 2,3,4,5 };
  13.     //序列式容器
  14.     vector<int> iVector(iArr, iArr + 4);
  15.     list<int> iList(iArr, iArr + 4);
  16.     deque<int> iDeque(iArr, iArr + 4);
  18.     //容器适配器
  19.     queue<int> iQueue(iDeque);                         // 队列 先进先出
  20.     stack<int> iStack(iDeque);                             // 栈 先进后出
  21.     priority_queue<int> iPQueue(iArr, iArr + 4);  // 优先队列，按优先权 
  23.     //序列式容器遍历——3种方法
  24.     //序列式容器遍历   迭代器+仿函数遍历
  25.     for_each( iVector.begin(), iVector.end(), Display() );
  26.     cout << endl;
  27.     //序列式容器遍历   迭代器+循环遍历    
  28.     for (auto it = iList.begin(); it != iList.end(); it++)
  29.     {
  30.         cout << *it << " ";
  31.     }
  32.     cout << endl;
  33.     //序列式容器遍历   for (auto i : s)
  34.     for (auto i:iDeque)
  35.     {
  36.         cout <<i<< " ";
  37.     }
  39.     //容器适配器遍历
  40.     while ( !iQueue.empty() )
  41.     {
  42.         cout << iQueue.front() << " ";  // 1  2 3 4
  43.         iQueue.pop();
  44.     }
  45.     cout << endl;
  47.     while (!iStack.empty())
  48.     {
  49.         cout << iStack.top() << " ";    // 4 3  2  1
  50.         iStack.pop();
  51.     }
  52.     cout << endl;
  54.     while (!iPQueue.empty())
  55.     {
  56.         cout << iPQueue.top() << " "; // 4 3 2 1
  57.         iPQueue.pop();
  58.     }
  59.     cout << endl;
  61.     return 0;
  62. }

注：容器的遍历可参考 c++ vector容器遍历方式 、 for(auto &i:s)和for(auto i:s)区别 ，仿函数参考 c++仿函数 functor 。

  • 关联式容器（Associative Containers）：每个数据元素都是由一个键（key）和值（Value）组成，当元素被插入到容器时，按其键以某种特定规则放入适当位置；常见的STL关联容器如：set，multiset，map，multimap；
  1. struct Display
  2. {
  3.     void operator()(pair<string, double> info)
  4.     {
  5.         cout << info.first << ": " << info.second << endl;
  6.     }
  7. };
  9. int main()
  10. {
  11.     map<string, double> studentSocres;
  12.     // []运算符作用：查找与Key匹配的元素（不存在则使用默认映射插入），返回的是Value的引用(意味着外部可以更新Value)
  13.     studentSocres["LiMing"] = 95.0; 
  14.     //insert逻辑：如果存在则不插入
  15.     studentSocres.insert(pair<string, double>("zhangsan", 100.0) );    
  16.     studentSocres.insert(map<string, double>::value_type("zhaoliu", 95.5) );
  17.     
  18.     for_each(studentSocres.begin(), studentSocres.end(), Display());
  19.     cout << endl;
  21.     //查找值
  22.     map<string, double>::iterator iter;
  23.     iter = studentSocres.find("zhaoliu");
  24.     if (iter != studentSocres.end())
  25.     {
  26.         cout << "Found the score is: " << iter->second << endl;
  27.     }
  28.     else
  29.     {
  30.         cout << "Didn't find the key." << endl;
  31.     }
  33.     // 使用迭代器完成遍历查找的过程
  34.     iter = studentSocres.begin();
  35.     while (iter != studentSocres.end())
  36.     {
  37.         if (iter->second < 98.0)  // 去除不是优秀的同学
  38.         {
  39.             studentSocres.erase(iter++);  // 注意：迭代器失效问题
  40.         }
  41.         else
  42.         {
  43.             iter++;
  44.         }
  45.     }
  46.     for_each(studentSocres.begin(), studentSocres.end(), Display());
  47.     cout << endl;
  49.     
  50.     for (iter = studentSocres.begin(); iter != studentSocres.end(); iter++)
  51.     {
  52.         if (iter->second <= 98.5)
  53.         {
  54.             iter = studentSocres.erase(iter);  // 注意：迭代器失效问题
  55.         }
  56.     }
  57.     for_each(studentSocres.begin(), studentSocres.end(), Display());
  58.     cout << endl;
  60.     studentSocres.erase(studentSocres.begin(), studentSocres.end());
  61.     for_each(studentSocres.begin(), studentSocres.end(), Display());
  62.     cout << endl;
  64.     return 0;
  65. }

仿函数（functor）

  • 仿函数一般不会单独使用，主要是为了搭配STL算法使用。
  • 函数指针不能满足STL对抽象性的要求，不能满足软件积木的要求，无法和STL其他组件搭配。
  • 本质就是类重载了一个operator()，创建一个行为类似函数的对象。

C++中仿函数/函数对象，函数指针的用法

  1. bool MySort(int a, int b) { return a < b; }
  3. void Display(int a) {     cout << a << " "; }
  5. template<class T>
  6. inline bool MySortT(T const& a, T const& b) { return a < b; }
  8. template<class T>
  9. inline void DisplayT(T const& a) { cout << a << " "; }
  11. struct SortF
  12. {
  13.     bool operator() (int a, int b) { return a < b; }
  14. };
  15. struct DisplayF
  16. {
  17.     void operator() (int a) { cout << a << " "; }
  18. };
  20. // C++仿函数模板
  21. template<class T>
  22. struct SortTF
  23. {
  24.     inline bool operator() (T const& a, T const& b) const { return a < b; }
  25. };
  27. template<class T>
  28. struct DisplayTF
  29. {
  30.     inline void operator() (T const& a) const { cout << a << " ";     }
  31. };
  34. int main()
  35. {
  36.     // C++方式
  37.     int arr[] = { 4, 3, 2, 1, 7 };
  38.     sort(arr, arr + 5, MySort);
  39.     for_each(arr, arr + 5, Display);
  40.     cout << endl;
  42.     // C++泛型
  43.     int arr2[] = { 4, 3, 2, 1, 7 };
  44.     sort(arr2, arr2 + 5, MySortT<int>);
  45.     for_each(arr2, arr2 + 5, DisplayT<int>);
  46.     cout << endl;
  48.     // C++仿函数
  49.     int arr3[] = { 4, 3, 2, 1, 7 };
  50.     sort(arr3, arr3 + 5, SortTF<int>() );
  51.     for_each(arr3, arr3 + 5, DisplayTF<int>());
  52.     cout << endl;
  54.     // C++仿函数模板
  55.     int arr4[] = { 4, 3, 2, 1, 7 };
  56.     sort(arr4, arr4 + 5, SortF());
  57.     for_each(arr4, arr4 + 5, DisplayF());
  58.     cout << endl;
  60.     return 0;
  61. }

算法（algorithm）

STL 中算法大致分为四类（包含于<algorithm>、<numeric>、<functional>）：

  • 非可变序列算法：指不直接修改其所操作的容器丙容的算法；
  • 可变序列算法：指可以修改它们所操作的容器内容的算法；
  • 排序算法：包括对序列进行排序和合并的算法、搜索算法以及有序序列上的集合操作；
  • 数值算法：对容器内容进行数值计算；查找，排序和通用算法，排列组合算法，数值算法，集合算法等算法；

最常见的算法包括：查找、排序和通用算法、排列组合算法、数值算法、集合算法等算法。

transform

transform函数的作用是将某操作应用于指定范围的每个元素，参考 C++学习transform函数的应用 ，示例如下：

  1. int main()
  2. {   
  3.     // transform和lambda表达式
  4.     int ones[] = { 1, 2, 3, 4, 5 };
  5.     int twos[] = { 10, 20, 30, 40, 50 };
  6.     int results[5];
  7.     transform(ones, ones + 5, twos, results, std::plus<int>()); // 数组元素依次相加并返回
  8.     for_each(results, results + 5, [ ](int a)->void { cout << a << endl; } ); // lambda表达式（匿名函数）
  9.     cout << endl;
  11.     return 0;
  12. }

查找

查找、统计相关的算法如下：

  1. int main()
  2. { 
  3.     int arr[] = { 0, 1, 2, 3, 3, 4, 4, 5, 6, 6, 7, 7, 7, 8 };
  4.     int len = sizeof(arr) / sizeof(arr[0]);
  5.     vector<int> iA(arr + 2, arr + 6);   // {2,3,3,4}
  6.     
  7.     // 统计6的个数
  8.     cout << count(arr, arr + len, 6) << endl; 
  9.     // 统计<7的个数， bind2nd已经启用
  10.     cout << count_if(arr, arr + len, bind2nd(less<int>(),  7) ) << endl; 
  11.      // 9找不到，二分法查找
  12.     cout << binary_search(arr, arr + len, 9) << endl;  
  13.     // 查找子序列，不存在时返回负值
  14.     cout << *search(arr, arr + len, iA.begin(), iA.end()) << endl; 
  16.     cout << endl;
  18.     return 0;
  19. }

上面使用了“arr + len”，但数组名不是指针，只是可以转换为指向其指代实体的指针，参考 C/C++中数组名退化为指针的情况。
注：binder1st、binder2nd在 c + + 11 中已弃用，在 c + + 17 中删除。

全排列

输入一个不存在重复字符的字符串，打印出字符串中字符的全排列，比如：
输入: "123" 321 = 3!
输出: 123 132 213 231 321 312

  1. //f(123) = 1+f(23), f(23) = 2+f(3), f(3)  = 3  递归
  2. void swap(char* a, char* b)
  3. {
  4.     char temp = *a;
  5.     *a = *b;
  6.     *b = temp;
  7. }
  8. void Permutation(char* pStr, char* pPostion)
  9. {
  10.     // 基准点
  11.     if (*pPostion == '\0')
  12.     {
  13.         cout << pStr << endl;
  14.     }
  15.     else
  16.     {
  17.         for (char* pChar = pPostion; *pChar != '\0'; pChar++)
  18.         {
  19.             // 依次和后面的字符交换
  20.             swap(*pChar, *pPostion);
  22.             Permutation(pStr, pPostion + 1);
  24.             // 换回来
  25.             swap(*pChar, *pPostion);
  26.         }
  27.     }
  28. }
  30. int main()
  31. {
  32.     char test[] = "132";
  33.     Permutation(test, test);
  34.     cout << endl;
  36.     // 用STL输出全排列
  37.     // 注意：必须要保证数组顺序，从小到大
  38.     do
  39.     {
  40.         cout << test[0] << test[1] << test[2] << endl;
  41.     } while (next_permutation(test, test + 3));
  42.     cout << endl;
  44.     char test2[] = "321";
  45.     // 注意：必须要保证数组顺序，从大到小
  46.     do
  47.     {
  48.         cout << test2[0] << test2[1] << test2[2] << endl;
  49.     } while (prev_permutation(test2, test2 + 3));
  51.     return 0;
  52. }

迭代器（iterator）

迭代器是一种smart pointer，用于访问顺序容器和关联容器中的元素，相当于容器和操纵容器的算法之间的中介。
迭代器按照定义方式分成以下四种：

  • 正向迭代器：iterator
  • 常量正向迭代器：const_iterator
  • 反向迭代器：reverse_iterator
  • 常量反向迭代器：const_reverse_iteratorr
  1. int main()
  2. {
  3.     list<int> v;
  4.     v.push_back(3);
  5.     v.push_back(4);
  6.     v.push_front(2);
  7.     v.push_front(1);  // 1, 2, 3, 4
  9.     list<int>::const_iterator it;
  10.     for (it = v.begin(); it != v.end(); it++)
  11.     {
  12.         //*it += 1;
  13.         cout << *it << " ";
  14.     }
  15.     cout << endl;
  17.     // 注意：迭代器不支持<
  18.     //for (it = v.begin(); it < v.end(); it++)
  19.     //{
  20.     //    cout << *it << " ";
  21.     //}
  23.     cout <<v.front() << endl;
  24.     v.pop_front();  // 从顶部去除
  26.     list<int>::reverse_iterator it2;
  27.     for (it2 = v.rbegin(); it2 != v.rend(); it2++)
  28.     {
  29.         *it2 += 1;
  30.         cout << *it2 << " "; // 5 4 3
  31.     }
  32.     cout << endl;
  34.     return 0;
  35. }

容器适配器（adapter）

  • stack 堆栈：一种”先进后出”的容器，底层数据结构是使用的deque；
  1. #include<stack>//定义栈所需的头文件
  2. using namespace std;
  3. stack<int> s;//定义一个元素为int型的栈
  4. int a=10;
  5. s.push(a);//将a入栈
  6. s.pop();//出栈一个元素
  7. s.empty();//返回栈是否为空
  8. s.size();//返回栈的大小
  9. s.top();//返回栈顶元素
  • queue队列：一种”先进先出”的容器，底层数据结构是使用的deque；
  2. #include<queue>//定义队列所需的头文件
  3. using namespace std;
  4. queue<int> s;//定义一个元素为int型的栈
  5. int a=10;
  6. q.push(a);//将a队尾插入一个元素
  7. q.pop();//删除队头的元素
  8. q.empty();//返回队列是否为空，是的话返回1，不是返回0
  9. q.size();//返回队列的大小
  10. a=q.front();//返回队首元素
  11. a=q.back();//返回队尾元素
  • priority_queue 优先队列：一种特殊的队列，它能够在队列中进行排序（堆排序），底层实现结构是vector或者deque；
  1. priority_queue<int> pq;  // 默认是最大值优先
  2. //priority_queue<int, vector<int>, less<int> > pq2; //   最大值优先
  3. //priority_queue<int, vector<int>, greater<int> > pq3; // 最小值优先
  5. pq.push(2);
  6. pq.push(1);
  7. pq.push(3);
  8. pq.push(0);
  9. while (!pq.empty())
  10. {
  11.     int top = pq.top();
  12.     cout << " top is: " << top<< endl;
  13.     pq.pop();
  14. }
  15. cout << endl;

注：用法可参考 C++栈和队列（stack,queue,priority_queue) 。

空间配置器（allocator）

从使用的角度来看，allocator隐藏在其他组件中默默工作，不需要关心，但是从理解STL实现角度来看，它是需要首先分析的组件。 allocator的分析可以体现C++在性能和资源管理上优化思想。

  1. #include "jjalloc.h"
  2. #include <vector>
  3. using namespace std;
  5. int main()
  6. {
  7.     int ia[5] = { 0, 1, 2, 3, 4 };
  8.     unsigned int i;
  9.     //为vector配置自定义的空间配置器
  10.     vector<int, JJ::allocator<int> > iv(ia, ia + 5);
  11.     for (i = 0; i < iv.size(); i++)
  12.     {
  13.         cout << iv[i] << " ";
  14.     }
  15.     cout << endl;
  16.     return 0;
  17. }

注：《STL源码剖析》侯捷，SGISTL版本的可读性较强。

STL总结

  • STL的六大组件给软件编程带来了新的多态和复用，是现代C++语言高效的精髓；
  • 泛型和STL的学习路线很陡，建议初学者先学会基本使用和简单扩展；
  • 掌握了一定基础的情况下，可以通过进一步学习和分析源码，编写自己的组件来提升能力；

关于Boost库

Boost库是为C++语言标准库提供扩展的一些C++程序库的总称，由Boost社区组织开发、维护，Boost库可以与C++标准库完美共同工作，并且为其提供扩展功能。

Boost可为大致为20多个分类：字符串和文本处理库、容器库、算法库、函数对象和高阶编程库、综合类库等等。

具体见：https://www.boost.org/

个人认为如果C++标准库可以满足日常开发的需求，Boost库没有学习必要。

多线程

线程基础

使用C++11中Thread时注意线程安全问题，可以使用mutex等锁：

  1. #include <thread>
  2. #include <mutex>
  3. #include <iostream>
  4. using namespace std;
  6. mutex g_mutex;
  7. void T1()
  8. {
  9.     g_mutex.lock();
  10.     cout << "T1 Hello" << endl;
  11.     g_mutex.unlock();
  12. }
  13. void T2(const char* str)
  14. {
  15.     g_mutex.lock();
  16.     cout << "T2 " << str << endl;
  17.     g_mutex.unlock();
  18. }
  19. int main()
  20. {
  21.     thread t1(T1);
  22.     thread t2(T2, "Hello World");
  23.     t1.join();
  24.     //t2.join();
  25.     t2.detach();
  26.     cout << "Main Hi" << endl;
  28.     return 0;
  29. }

join()、detach()可参考
C++11多线程join()和detach()的理解 ：

  • join()函数是一个等待线程完成函数，主线程需要等待子线程运行结束了才可以结束；
  • detach()函数称为分离线程函数，使用detach()函数会让线程在后台运行，即说明主线程不会等待子线程运行结束才结束；

互斥锁mutex可以配合lock_guard、unique_lock使用，参考 c++11中的lock_guard和unique_lock使用浅析 。
原子操作atomic的也可用于线程同步，常用于变量资源，参考 C++原子操作 atomic的使用及效率 。

线程交换

  1. thread tW1([]()
  2. {
  3.     cout << "ThreadSwap1 " << endl;
  4. });
  5. thread tW2([]()
  6. {
  7.     cout << "ThreadSwap2 " << endl;
  8. });
  9. cout << "ThreadSwap1' id is " << tW1.get_id() << endl;
  10. cout << "ThreadSwap2' id is " << tW2.get_id() << endl;
  12. cout << "Swap after:" << endl;
  13. swap(tW1, tW2); 
  14. cout << "ThreadSwap1' id is " << tW1.get_id() << endl;
  15. cout << "ThreadSwap2' id is " << tW2.get_id() << endl;
  16. tW1.join();
  17. tW2.join();
  1. ThreadSwap1
  2. ThreadSwap2
  3. ThreadSwap1' id is 26136
  4. ThreadSwap2' id is 26612
  5. Swap after:
  6. ThreadSwap1' id is 26612
  7. ThreadSwap2' id is 26136

线程移动

  1. thread tM1( []() { ; } );
  2. //tM1.join();
  3. cout << "ThreadMove1' id is " << tM1.get_id() << endl;
  4. cout << "Move after:" << endl;
  5. thread tM2 = move(tM1);
  6. cout << "ThreadMove2' id is " << tM2.get_id() << endl;
  7. cout << "ThreadMove1' id is " << tM1.get_id() << endl;
  8. tM2.join();
  1. ThreadMove1' id is 17940
  2. Move after:
  3. ThreadMove2' id is 17940
  4. ThreadMove1' id is 0

推荐基本C++的书籍

  • 入门：
    《C++Primer》Stanley B.Lippman

  • 最佳实践：
    《C++高质量编程》林锐
    《Effective C++》候捷（译）
    《More Effective C++》候捷（译）
    《Effective STL》潘爱民（译）
    《The C++Programming Language》Bjarne Stroustrup

  • 深入：
    《STL源码剖析》候捷
    《COM本质论》Don Box
    《Exceptional C++》Addsion.Wesley
    《Inside the C++Object Model》Stanley B.Lippman
    《The Design and Evolution of C++》Bjarne Stroustrup

原文链接：http://www.cnblogs.com/timefiles/p/CppStudyNotesAdvancedProgramming.html

 友情链接：直通硅谷 　点职佳 　北美留学生论坛

C++热门文章

  • C/C++编程笔记：编写不会在C ++中编译的C程序，我教你呀！
  • 洛谷 P2085 最小函数值
  • 使用C++界面框架ImGUI开发一个简单程序
  • C++ Json解析CJsonObject的详细使用
  • C++编译错误杂记
  • 二分法（二）：采用二分法解决“最小化最大值问题”
  • C++实现json字符串与map的转换
  • C++借助curses库实现俄罗斯方块
  • 长乐培训Day5
  • 【OpenFOAM】——OpenFOAM入门算例学习

    • C++推荐文章

  • #8. 「模板」树链剖分
  • 预设型 DP
  • Standard Template Libary or C++ Standard Library
  • 一种优秀的虚拟机内存架构 - AQ
  • 如何让 MGR 不从 Primary 节点克隆数据？
  • TLScanary：Pwn中的利器
  • c++临时对象导致的生命周期问题
  • C++(Qt)-GIS开发-简易瓦片地图下载器
  • 逆向通达信 x 逆向微信 x 逆向Qt
  • C++面向对象

    • 本站QQ群：前端 618073944 | Java 606181507 | Python 626812652 | C/C++ 612253063 | 微信 634508462 | 苹果 692586424 | C#/.net 182808419 | PHP 305140648 | 运维 608723728

    W3xue 的所有内容仅供测试，对任何法律问题及风险不承担任何责任。通过使用本站内容随之而来的风险与本站无关。
    关于我们  |  意见建议  |  捐助我们  |  报错有奖  |  广告合作、友情链接（目前9元/月）请联系QQ：27243702 沸活量
    皖ICP备17017327号-2　皖公网安备34020702000426号