C++11

auto & decltype

关于C++11新特性，最先提到的肯定是类型推导，C++11引入了auto和decltype关键字，使用他们可以在编译期就推导出变量或者表达式的类型，方便开发者编码也简化了代码。

  • auto：让编译器在编译器就推导出变量的类型，可以通过=右边的类型推导出变量的类型。

    1. auto a = 10; // 10是int型，可以自动推导出a是int

  • decltype：相对于auto用于推导变量类型，而decltype则用于推导表达式类型，这里只用于编译器分析表达式的类型，表达式实际不会进行运算。

    1. cont int &i = 1;int a = 2;decltype(i) b = 2; // b是const int&

    左值右值

    众所周知C++11新增了右值引用，这里涉及到很多概念：

  • 左值：可以取地址并且有名字的东西就是左值。

  • 右值：不能取地址的没有名字的东西就是右值。
  • 纯右值：运算表达式产生的临时变量、不和对象关联的原始字面量、非引用返回的临时变量、lambda表达式等都是纯右值。
  • 将亡值：可以理解为即将要销毁的值。
  • 左值引用：对左值进行引用的类型。
  • 右值引用：对右值进行引用的类型。
  • 移动语义：转移资源所有权，类似于转让或者资源窃取的意思，对于那块资源，转为自己所拥有，别人不再拥有也不会再使用。
  • 完美转发：可以写一个接受任意实参的函数模板，并转发到其它函数，目标函数会收到与转发函数完全相同的实参。

  • 返回值优化：当函数需要返回一个对象实例时候，就会创建一个临时对象并通过复制构造函数将目标对象复制到临时对象，这里有复制构造函数和析构函数会被多余的调用到，有代价，而通过返回值优化，C++标准允许省略调用这些复制构造函数。

    列表初始化

    在C++11中可以直接在变量名后面加上初始化列表来进行对象的初始化。

    std::function & std::bind & lambda表达式

    c++11新增了std::function、std::bind、lambda表达式等封装使函数调用更加方便。

    模板的改进

    C++11关于模板有一些细节的改进：

  • 模板的右尖括号

  • 模板的别名

  • 函数模板的默认模板参数

    并发

    c++11关于并发引入了好多好东西，有：

  • std::thread相关

  • std::mutex相关
  • std::lock相关
  • std::atomic相关
  • std::call_once相关
  • volatile相关
  • std::condition_variable相关
  • std::future相关

  • async相关

    智能指针

    很多人谈到c++，说它特别难，可能有一部分就是因为c++的内存管理，不像java那样有虚拟机动态的管理内存，在程序运行过程中可能就会出现内存泄漏，然而这种问题其实都可以通过c++11引入的智能指针来解决，这种内存管理还是c++语言的优势，因为尽在掌握。
    c++11引入了三种智能指针：

  • std::shared_ptr

  • std::weak_ptr
  • std::unique_ptr

    基于范围的for循环

    看代码 ```cpp vector vec;

for (auto iter = vec.begin(); iter != vec.end(); iter++) { // before c++11 cout << *iter << endl; }

for (int i : vec) { // c++11基于范围的for循环 cout << “i” << endl; }

  1. <a name="xtj3c"></a>
  2. ### 委托构造函数
  3. 委托构造函数允许在同一个类中一个构造函数调用另外一个构造函数，可以在变量初始化时简化操作，通过代码来感受下委托构造函数的妙处：<br />不使用委托构造函数：
  4. ```cpp
  5. struct A {
  6.     A(){}
  7.     A(int a) { a_ = a; }
  9.     A(int a, int b) { // 好麻烦
  10.         a_ = a;
  11.         b_ = b;
  12.     }
  14.     A(int a, int b, int c) { // 好麻烦
  15.         a_ = a;
  16.         b_ = b;
  17.         c_ = c;
  18.     }
  20.     int a_;
  21.     int b_;
  22.     int c_;
  23. };

使用委托构造函数：

  1. struct A {
  2.     A(){}
  3.     A(int a) { a_ = a; }
  5.     A(int a, int b) : A(a) { b_ = b; }
  7.     A(int a, int b, int c) : A(a, b) { c_ = c; }
  9.     int a_;
  10.     int b_;
  11.     int c_;
  12. };

初始化变量是不是方便了许多。

继承构造函数

继承构造函数可以让派生类直接使用基类的构造函数，如果有一个派生类，希望派生类采用和基类一样的构造方式，可以直接使用基类的构造函数，而不是再重新写一遍构造函数，老规矩，看代码：
不使用继承构造函数：

  1. struct Base {
  2.     Base() {}
  3.     Base(int a) { a_ = a; }
  5.     Base(int a, int b) : Base(a) { b_ = b; }
  7.     Base(int a, int b, int c) : Base(a, b) { c_ = c; }
  9.     int a_;
  10.     int b_;
  11.     int c_;
  12. };
  14. struct Derived : Base {
  15.     Derived() {}
  16.     Derived(int a) : Base(a) {} // 好麻烦
  17.     Derived(int a, int b) : Base(a, b) {} // 好麻烦
  18.     Derived(int a, int b, int c) : Base(a, b, c) {} // 好麻烦
  19. };
  20. int main() {
  21.     Derived a(1, 2, 3);
  22.     return 0;
  23. }

使用继承构造函数：

  1. struct Base {
  2.     Base() {}
  3.     Base(int a) { a_ = a; }
  5.     Base(int a, int b) : Base(a) { b_ = b; }
  7.     Base(int a, int b, int c) : Base(a, b) { c_ = c; }
  9.     int a_;
  10.     int b_;
  11.     int c_;
  12. };
  14. struct Derived : Base {
  15.     using Base::Base;
  16. };
  18. int main() {
  19.     Derived a(1, 2, 3);
  20.     return 0;
  21. }

只需要使用using Base::Base继承构造函数，就免去了很多重写代码的麻烦。

nullptr

nullptr是c++11用来表示空指针新引入的常量值，在c++中如果表示空指针语义时建议使用nullptr而不要使用NULL，因为NULL本质上是个int型的0，其实不是个指针。举例：

  1. void func(void *ptr) {
  2.     cout << "func ptr" << endl;
  3. }
  5. void func(int i) {
  6.     cout << "func i" << endl;
  7. }
  9. int main() {
  10.     func(NULL); // 编译失败，会产生二义性
  11.     func(nullptr); // 输出func ptr
  12.     return 0;
  13. }

final & override

c++11关于继承新增了两个关键字，final用于修饰一个类，表示禁止该类进一步派生和虚函数的进一步重载，override用于修饰派生类中的成员函数，标明该函数重写了基类函数，如果一个函数声明了override但父类却没有这个虚函数，编译报错，使用override关键字可以避免开发者在重写基类函数时无意产生的错误。
示例代码1：

  1. struct Base {
  2.     virtual void func() {
  3.         cout << "base" << endl;
  4.     }
  5. };
  7. struct Derived : public Base{
  8.     void func() override { // 确保func被重写
  9.         cout << "derived" << endl;
  10.     }
  12.     void fu() override { // error，基类没有fu()，不可以被重写
  13.     }
  14. };

示例代码2：

  1. struct Base final {
  2.     virtual void func() {
  3.         cout << "base" << endl;
  4.     }
  5. };
  7. struct Derived : public Base{ // 编译失败，final修饰的类不可以被继承
  8.     void func() override {
  9.         cout << "derived" << endl;
  10.     }
  11. };

default

c++11引入default特性，多数时候用于声明构造函数为默认构造函数，如果类中有了自定义的构造函数，编译器就不会隐式生成默认构造函数，如下代码：

  1. struct A {
  2.     int a;
  3.     A(int i) { a = i; }
  4. };
  6. int main() {
  7.     A a; // 编译出错
  8.     return 0;
  9. }

上面代码编译出错，因为没有匹配的构造函数，因为编译器没有生成默认构造函数，而通过default，程序员只需在函数声明后加上“=default;”，就可将该函数声明为 defaulted 函数，编译器将为显式声明的 defaulted 函数自动生成函数体，如下：

  1. struct A {
  2.     A() = default;
  3.     int a;
  4.     A(int i) { a = i; }
  5. };
  7. int main() {
  8.     A a;
  9.     return 0;
  10. }

编译通过。

delete

c++中，如果开发人员没有定义特殊成员函数，那么编译器在需要特殊成员函数时候会隐式自动生成一个默认的特殊成员函数，例如拷贝构造函数或者拷贝赋值操作符，如下代码：

  1. struct A {
  2.     A() = default;
  3.     int a;
  4.     A(int i) { a = i; }
  5. };
  7. int main() {
  8.     A a1;
  9.     A a2 = a1;  // 正确，调用编译器隐式生成的默认拷贝构造函数
  10.     A a3;
  11.     a3 = a1;  // 正确，调用编译器隐式生成的默认拷贝赋值操作符
  12. }

有时候想禁止对象的拷贝与赋值，可以使用delete修饰，如下：

  1. struct A {
  2.     A() = default;
  3.     A(const A&) = delete;
  4.     A& operator=(const A&) = delete;
  5.     int a;
  6.     A(int i) { a = i; }
  7. };
  9. int main() {
  10.     A a1;
  11.     A a2 = a1;  // 错误，拷贝构造函数被禁用
  12.     A a3;
  13.     a3 = a1;  // 错误，拷贝赋值操作符被禁用
  14. }

delele函数在c++11中很常用，std::unique_ptr就是通过delete修饰来禁止对象的拷贝的。

explicit

explicit专用于修饰构造函数，表示只能显式构造，不可以被隐式转换，根据代码看explicit的作用：
不用explicit：

  1. struct A {
  2.     A(int value) { // 没有explicit关键字
  3.         cout << "value" << endl;
  4.     }
  5. };
  7. int main() {
  8.     A a = 1; // 可以隐式转换
  9.     return 0;
  10. }

使用explicit:

  1. struct A {
  2.     explicit A(int value) {
  3.         cout << "value" << endl;
  4.     }
  5. };
  7. int main() {
  8.     A a = 1; // error，不可以隐式转换
  9.     A aa(2); // ok
  10.     return 0;
  11. }

const

因为要讲后面的constexpr，所以这里简单介绍下const。
const字面意思为只读，可用于定义变量，表示变量是只读的，不可以更改，如果更改，编译期间就会报错。
主要用法如下：

  1. 用于定义常量，const的修饰的变量不可更改。

    1. const int value = 5;

  2. 指针也可以使用const，这里有个小技巧，从右向左读，即可知道const究竟修饰的是指针还是指针所指向的内容。

    1. char *const ptr; // 指针本身是常量
    2. const char* ptr; // 指针指向的变量为常量

  3. 在函数参数中使用const，一般会传递类对象时会传递一个const的引用或者指针，这样可以避免对象的拷贝，也可以防止对象被修改。

    1. class A{};
    2. void func(const A& a);

  4. const修饰类的成员变量，表示是成员常量，不能被修改，可以在初始化列表中被赋值。

    1. class A {
    2.  const int value = 5;
    3. };
    4. class B {
    5.  const int value;
    6.  B(int v) : value(v){}
    7. };

  5. 修饰类成员函数，表示在该函数内不可以修改该类的成员变量。

    1. class A{
    2.  void func() const;
    3. };

  6. 修饰类对象，类对象只能调用该对象的const成员函数。

    1. class A {
    2.  void func() const;
    3. };
    4. const A a;
    5. a.func();

    constexpr

    constexpr是c++11新引入的关键字，用于编译时的常量和常量函数，这里直接介绍constexpr和const的区别：
    两者都代表可读，const只表示read only的语义，只保证了运行时不可以被修改，但它修饰的仍然有可能是个动态变量，而constexpr修饰的才是真正的常量，它会在编译期间就会被计算出来，整个运行过程中都不可以被改变，constexpr可以用于修饰函数，这个函数的返回值会尽可能在编译期间被计算出来当作一个常量，但是如果编译期间此函数不能被计算出来，那它就会当作一个普通函数被处理。如下代码： ```cpp

    include

    using namespace std;

constexpr int func(int i) { return i + 1; }

int main() { int i = 2; func(i);// 普通函数 func(2);// 编译期间就会被计算出来 }

  1. <a name="57e68740"></a>
  2. ### enum class
  3. c++11新增有作用域的枚举类型，看代码<br />不带作用域的枚举代码：
  4. ```cpp
  5. enum AColor {
  6.     kRed,
  7.     kGreen,
  8.     kBlue
  9. };
  11. enum BColor {
  12.     kWhite,
  13.     kBlack,
  14.     kYellow
  15. };
  17. int main() {
  18.     if (kRed == kWhite) {
  19.         cout << "red == white" << endl;
  20.     }
  21.     return 0;
  22. }

如上代码，不带作用域的枚举类型可以自动转换成整形，且不同的枚举可以相互比较，代码中的红色居然可以和白色比较，这都是潜在的难以调试的bug，而这种完全可以通过有作用域的枚举来规避。
有作用域的枚举代码：

  1. enum class AColor {
  2.     kRed,
  3.     kGreen,
  4.     kBlue
  5. };
  7. enum class BColor {
  8.     kWhite,
  9.     kBlack,
  10.     kYellow
  11. };
  13. int main() {
  14.     if (AColor::kRed == BColor::kWhite) { // 编译失败
  15.         cout << "red == white" << endl;
  16.     }
  17.     return 0;
  18. }

使用带有作用域的枚举类型后，对不同的枚举进行比较会导致编译失败，消除潜在bug，同时带作用域的枚举类型可以选择底层类型，默认是int，可以改成char等别的类型。

  1. enum class AColor : char {
  2.     kRed,
  3.     kGreen,
  4.     kBlue
  5. };

平时编程过程中使用枚举，一定要使用有作用域的枚举取代传统的枚举。

非受限联合体

c++11之前union中数据成员的类型不允许有非POD类型，而这个限制在c++11被取消，允许数据成员类型有非POD类型，看代码：

  1. struct A {
  2.     int a;
  3.     int *b;
  4. };
  6. union U {
  7.     A a; // 非POD类型 c++11之前不可以这样定义联合体
  8.     int b;
  9. };

对于什么是POD类型，大家可以自行查下资料，大体上可以理解为对象可以直接memcpy的类型。

sizeof

c++11中sizeof可以用的类的数据成员上，看代码：
c++11前：

  1. struct A {
  2.     int data[10];
  3.     int a;
  4. };
  6. int main() {
  7.     A a;
  8.     cout << "size " << sizeof(a.data) << endl;
  9.     return 0;
  10. }

c++11后：

  1. struct A {
  2.     int data[10];
  3.     int a;
  4. };
  6. int main() {
  7.     cout << "size " << sizeof(A::data) << endl;
  8.     return 0;
  9. }

想知道类中数据成员的大小在c++11中是不是方便了许多，而不需要定义一个对象，在计算对象的成员大小。

assertion

  1. static_assert(true/false, message);

c++11引入static_assert声明，用于在编译期间检查，如果第一个参数值为false，则打印message，编译失败。

自定义字面量

c++11可以自定义字面量，平时c++中都或多或少使用过chrono中的时间，例如：

  1. std::this_thread::sleep_for(std::chrono::milliseconds(100)); // 100ms
  2. std::this_thread::sleep_for(std::chrono::seconds(100)); // 100s

其实没必要这么麻烦，也可以这么写：

  1. std::this_thread::sleep_for(100ms); // c++14里可以这么使用，这里只是举个自定义字面量使用的例子
  2. std::this_thread::sleep_for(100s);

这就是自定义字面量的使用，示例如下：

  1. struct mytype {
  2.     unsigned long long value;
  3. };
  4. constexpr mytype operator"" _mytype ( unsigned long long n ) {
  5.     return mytype{n};
  6. }
  7. mytype mm = 123_mytype;
  8. cout << mm.value << endl;

关于自定义字面量，可以看下chrono的源代码。

内存对齐

什么是内存对齐

理论上计算机对于任何变量的访问都可以从任意位置开始，然而实际上系统会对这些变量的存放地址有限制，通常将变量首地址设为某个数N的倍数，这就是内存对齐。

为什么要内存对齐

  1. 硬件平台限制，内存以字节为单位，不同硬件平台不一定支持任何内存地址的存取，一般可能以双字节、4字节等为单位存取内存，为了保证处理器正确存取数据，需要进行内存对齐。
  2. 提高CPU内存访问速度，一般处理器的内存存取粒度都是N的整数倍，假如访问N大小的数据，没有进行内存对齐，有可能就需要两次访问才可以读取出数据，而进行内存对齐可以一次性把数据全部读取出来，提高效率。

在c++11之前如果想创建内存对齐需要：

  1. void align_cpp11_before(){
  2.     static char data[sizeof(void *) + sizeof(A)];
  3.     const uintptr_t kAlign = sizeof(void *) - 1;
  4.     char *align_ptr =
  5.         reinterpret_cast<char *>(reinterpret_cast<uintptr_t>(data + kAlign) & ~kAlign);
  6.     A *attr = new (align_ptr) A;
  7. }

c++11关于内存对齐新增了一些函数：

  1. void align_cpp11_after()
  2. {
  3.     static std::aligned_storage<sizeof(A),
  4.     alignof(A)>::type data;
  5.     A *attr = new (&data) A;
  6. }

还有：alignof()、std::alignment_of()、alignas()。

thread_local

c++11引入thread_local，用thread_local修饰的变量具有thread周期，每一个线程都拥有并只拥有一个该变量的独立实例，一般用于需要保证线程安全的函数中。

  1. #include <iostream>
  2. #include <thread>
  4. class A {
  5.     public:
  6.     A() {}
  7.     ~A() {}
  9.     void test(const std::string &name) {
  10.         thread_local int count = 0;
  11.         ++count;
  12.         std::cout << name << ": " << count << std::endl;
  13.     }
  14. };
  16. void func(const std::string &name) {
  17.     A a1;
  18.     a1.test(name);
  19.     a1.test(name);
  20.     A a2;
  21.     a2.test(name);
  22.     a2.test(name);
  23. }
  25. int main() {
  26.     std::thread(func, "thread1").join();
  27.     std::thread(func, "thread2").join();
  28.     return 0;
  29. }

输出：

  1. thread1: 1
  2. thread1: 2
  3. thread1: 3
  4. thread1: 4
  5. thread2: 1
  6. thread2: 2
  7. thread2: 3
  8. thread2: 4

验证上述说法，对于一个线程私有变量，一个线程拥有且只拥有一个该实例，类似于static。

基础数值类型

c++11新增了几种数据类型：long long、char16_t、char32_t等

随机数功能

c++11关于随机数功能则较之前丰富了很多，典型的可以选择概率分布类型，先看如下代码：

  1. #include <time.h>
  3. #include <iostream>
  4. #include <random>
  6. using namespace std;
  8. int main() {
  9.     std::default_random_engine random(time(nullptr));
  11.     std::uniform_int_distribution<int> int_dis(0, 100); // 整数均匀分布
  12.     std::uniform_real_distribution<float> real_dis(0.0, 1.0); // 浮点数均匀分布
  14.     for (int i = 0; i < 10; ++i) {
  15.         cout << int_dis(random) << ' ';
  16.     }
  17.     cout << endl;
  19.     for (int i = 0; i < 10; ++i) {
  20.         cout << real_dis(random) << ' ';
  21.     }
  22.     cout << endl;
  24.     return 0;
  25. }

输出：

  1. 38 100 93 7 66 0 68 99 41 7
  2. 0.232202 0.617716 0.959241 0.970859 0.230406 0.430682 0.477359 0.971858 0.0171148 0.64863

代码中举例的是整数均匀分布和浮点数均匀分布，c++11提供的概率分布类型还有好多，例如伯努利分布、正态分布等，具体可以见最后的参考资料。

正则表达式

c++11引入了regex库更好的支持正则表达式，见代码：

  1. #include <iostream>
  2. #include <iterator>
  3. #include <regex>
  4. #include <string>
  6. int main() {
  7.     std::string s = "I know, I'll use2 regular expressions.";
  8.     // 忽略大小写
  9.     std::regex self_regex("REGULAR EXPRESSIONS", std::regex_constants::icase);
  10.     if (std::regex_search(s, self_regex)) {
  11.         std::cout << "Text contains the phrase 'regular expressions'\n";
  12.     }
  14.     std::regex word_regex("(\\w+)");  // 匹配字母数字等字符
  15.     auto words_begin = std::sregex_iterator(s.begin(), s.end(), word_regex);
  16.     auto words_end = std::sregex_iterator();
  18.     std::cout << "Found " << std::distance(words_begin, words_end) << " words\n";
  20.     const int N = 6;
  21.     std::cout << "Words longer than " << N << " characters:\n";
  22.     for (std::sregex_iterator i = words_begin; i != words_end; ++i) {
  23.         std::smatch match = *i;
  24.         std::string match_str = match.str();
  25.         if (match_str.size() > N) {
  26.             std::cout << " " << match_str << '\n';
  27.         }
  28.     }
  30.     std::regex long_word_regex("(\\w{7,})");
  31.     // 超过7个字符的单词用[]包围
  32.     std::string new_s = std::regex_replace(s, long_word_regex, "[$&]");
  33.     std::cout << new_s << '\n';
  34. }

chrono

c++11关于时间引入了chrono库，源于boost，功能强大，chrono主要有三个点：

  • duration
  • time_point

  • clocks

    duration

    std::chrono::duration表示一段时间，常见的单位有s、ms等，示例代码：

    1. // 拿休眠一段时间举例，这里表示休眠100ms
    2. std::this_thread::sleep_for(std::chrono::milliseconds(100));

    sleep_for里面其实就是std::chrono::duration，表示一段时间，实际是这样：

    1. typedef duration<int64_t, milli> milliseconds;
    2. typedef duration<int64_t> seconds;

    duration具体模板如下：

    1. template <class Rep, class Period = ratio<1> > class duration;

    Rep表示一种数值类型，用来表示Period的数量，比如int、float、double，Period是ratio类型，用来表示【用秒表示的时间单位】比如second，常用的duration已经定义好了，在std::chrono::duration下：

  • ratio<3600, 1>：hours

  • ratio<60, 1>：minutes
  • ratio<1, 1>：seconds
  • ratio<1, 1000>：microseconds
  • ratio<1, 1000000>：microseconds
  • ratio<1, 1000000000>：nanosecons

ratio的具体模板如下：

  1. template <intmax_t N, intmax_t D = 1> class ratio;

N代表分子，D代表分母，所以ratio表示一个分数，可以自定义Period，比如ratio<2, 1>表示单位时间是2秒。

time_point

表示一个具体时间点，如2020年5月10日10点10分10秒，拿获取当前时间举例：

  1. std::chrono::time_point<std::chrono::high_resolution_clock> Now() {
  2.     return std::chrono::high_resolution_clock::now();
  3. }
  4. // std::chrono::high_resolution_clock为高精度时钟，下面会提到

clocks
时钟，chrono里面提供了三种时钟：

  • steady_clock
  • system_clock

  • high_resolution_clock

    steady_clock

    稳定的时间间隔，表示相对时间，相对于系统开机启动的时间，无论系统时间如何被更改，后一次调用now()肯定比前一次调用now()的数值大，可用于计时。

    system_clock

    表示当前的系统时钟，可以用于获取当前时间：

    1. int main() {
    2.   using std::chrono::system_clock;
    3.   system_clock::time_point today = system_clock::now();
    5.   std::time_t tt = system_clock::to_time_t(today);
    6.   std::cout << "today is: " << ctime(&tt);
    8.   return 0;
    9. }
    10. // today is: Sun May 10 09:48:36 2020

    high_resolution_clock

    high_resolution_clock表示系统可用的最高精度的时钟，实际上就是system_clock或者steady_clock其中一种的定义，官方没有说明具体是哪个，不同系统可能不一样，看gcc chrono源码中high_resolution_clock是steady_clock的typedef。

    新增数据结构

  • std::forward_list：单向链表，只可以前进，在特定场景下使用，相比于std::list节省了内存，提高了性能

    1. std::forward_list<int> fl = {1, 2, 3, 4, 5};
    2. for (const auto &elem : fl) {
    3.   cout << elem;
    4. }

  • std::unordered_set：基于hash表实现的set，内部不会排序，使用方法和set类似

  • std::unordered_map：基于hash表实现的map，内部不会排序，使用方法和set类似
  • std::array：数组，在越界访问时抛出异常，建议使用std::array替代普通的数组

  • std::tuple：元组类型，类似pair，但比pair扩展性好

    1. typedef std::tuple<int, double, int, double> Mytuple;
    2. Mytuple t(0, 1, 2, 3);
    3. std::cout << "0 " << std::get<0>(t);
    4. std::cout << "1 " << std::get<1>(t);
    5. std::cout << "2 " << std::get<2>(t);
    6. std::cout << "3 " << std::get<3>(t);

    新增算法

  • all_of：检测表达式是否对范围[first, last)中所有元素都返回true，如果都满足，则返回true

    1. std::vector<int> v(10, 2);
    2. if (std::all_of(v.cbegin(), v.cend(), [](int i) { return i % 2 == 0; })) {
    3.   std::cout << "All numbers are even\n";
    4. }

  • any_of：检测表达式是否对范围[first, last)中至少一个元素返回true，如果满足，则返回true，否则返回false，用法和上面一样

  • none_of：检测表达式是否对范围[first, last)中所有元素都不返回true，如果都不满足，则返回true，否则返回false，用法和上面一样
  • find_if_not：找到第一个不符合要求的元素迭代器，和find_if相反
  • copy_if：复制满足条件的元素

  • itoa：对容器内的元素按序递增

    1. std::vector<int> l(10);
    2. std::iota(l.begin(), l.end(), 19); // 19为初始值
    3. for (auto n : l) std::cout << n << ' ';
    4. // 19 20 21 22 23 24 25 26 27 28

  • minmax_element：返回容器内最大元素和最小元素位置

    1. int main() {
    2.   std::vector<int> v = {3, 9, 1, 4, 2, 5, 9};
    4.   auto result = std::minmax_element(v.begin(), v.end());
    5.   std::cout << "min element at: " << *(result.first) << '\n';
    6.   std::cout << "max element at: " << *(result.second) << '\n';
    7.   return 0;
    8. }
    9. // min element at: 1
    10. // max element at: 9

  • is_sorted、is_sorted_until：返回容器内元素是否已经排好序。