现代c++

1

char *str = "hello world!"; // 将出现弃用警告

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

// foo.h
#ifdef __cplusplus
extern "C" {
#endif

int add(int x, int y);

#ifdef __cplusplus
}
#endif


// foo.c
int add(int x, int y) { 
    return x+y;
}

// 1.1.cpp
#include "foo.h"
#include <iostream>
#include <functional>
int main() {
    [out = std::ref(std::cout << "Result from C code: " << add(1, 2))](){
        out.get() << ".\n";
    }();

    return 0; 
}

// 应先使用 gcc 编译 C 语言的代码 gcc -c foo.c
// 编译出 foo.o 文件，再使用 clang++ 将 C++ 代码和 .o 文件链接起来(或者都编译为 .o 再统一 链接) clang++ 1.1.cpp foo.o -std=c++2a -o xxx.out

1
2
3
4

void foo (char*);
void foo (int);

char*  ch = NULL;   // 会使调用 void foo(int)，导致违反本意

1
2
3
4
5
6
7
8

constexpr int fibonacci(const int n) {

    // 循环语句在 c++14 才支持
    if(n == 1) return 1;
    if(n == 2) return 1;
    
    return fibonacci(n-1) + fibonacci(n-2);
}

1
2
3

constexpr int fibonacci(const int n) {
    return n == 1 || n == 2 ? 1 : fibonacci(n-1)+fibonacci(n-2);
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

#include <iostream>
#include <vector>
#include <algorithm>
int main() 
{
    std::vector<int> vec = {1, 2, 3, 4};
    
    // 在 c++17 之前
    const std::vector<int>::iterator itr = std::find(vec.begin(), vec.end(), 2);
    if (itr != vec.end()) {
        *itr = 3;
    }

    // 需要重新定义一个新的变量
    const std::vector<int>::iterator itr2 = std::find(vec.begin(), vec.end(), 3);
    if (itr2 != vec.end()) {
        *itr2 = 4;
    }

    // 将输出 1, 4, 3, 4
    for (std::vector<int>::iterator element = vec.begin(); element != vec.end(); ++element)
        std::cout << *element << std::endl;
}

1
2
3
4
5
6
7

// 将临时变量放到 if 语句内
// 注意，if 条件是由两个表达式组成
if (const std::vector<int>::iterator itr 
        = std::find(vec.begin(), vec.end(), 3);
        itr != vec.end()) {
    *itr = 4; 
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

#include <iostream>
#include <vector>
class Foo 
{
    public:
    int value_a;
    int value_b;

    // 类的初始化
    Foo(int a, int b) : value_a(a), value_b(b) {}
};

int main()
{
    // before C++11
    int arr[3] = {1, 2, 3};
    Foo foo(1, 2);
    std::vector<int> vec = {1, 2, 3, 4, 5};

    std::cout << "arr[0]: " << arr[0] << std::endl;
    std::cout << "foo:" << foo.value_a << ", " << foo.value_b << std::endl;

    for (std::vector<int>::iterator it = vec.begin(); it != vec.end(); ++it) {
        std::cout << *it << std::endl;
    }

    return 0; 
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

#include <initializer_list>
#include <vector>

class MagicFoo
{
public:
    std::vector<int> vec;
    MagicFoo(std::initializer_list<int> list) {
        for (std::initializer_list<int>::iterator it = list.begin();
                it != list.end(); ++it)
            vec.push_back(*it);
    }
};

int main()
{
    // after C++11
    MagicFoo magicFoo = {1, 2, 3, 4, 5};
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

class MagicFoo
{
public:
    void foo(std::initializer_list<int> list) {
        for (std::initializer_list<int>::iterator it = list.begin();
                it != list.end(); ++it)
            vec.push_back(*it);
    }
};

// 使用时候 magicFoo.foo({6,7,8,9});

1

Foo foo2 {3, 4};

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

#include <iostream>
#include <tuple>

std::tuple<int, double, std::string> f()
{
    return std::make_tuple(1, 2.3, "456");
}

int main()
{
    auto [x, y, z] = f();
    std::cout << x << ", " << y << ", " << z << std::endl; return 0;
}

1
2
3
4
5
6
7

// c++11 之前
for(vector<int>::const_iterator it = vec.cbegin(); itr != vec.cend(); ++it)
    ...

// c++11 之后使用 auto
for (auto it = list.begin(); it != list.end(); ++it)
    ...

1
2
3

auto i = 5; // i 被推导为 int

auto arr = new auto(10); // arr 被推导为 int *

1
2
3
4
5
6
7
8
9

int add(auto x, auto y)
{
    return x+y;
}

auto i = 5; // 被推导为 int
auto j = 6; // 被推导为 int

std::cout << add(i, j) << std::endl;

1

decltype(表达式)

1
2
3

auto x = 1;
auto y = 2;
decltype(x+y) z;

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

auto x = 1;
auto y = 2;
decltype(x+y) z;

if (std::is_same<decltype(x), int>::value)
    std::cout << "type x == int" << std::endl;
if (std::is_same<decltype(x), float>::value)
    std::cout << "type x == float" << std::endl;
if (std::is_same<decltype(x), decltype(z)>::value)
    std::cout << "type z == type x" << std::endl;

1
2

type x == int
type z == type x

1
2
3
4
5

template<typename R, typename T, typename U>
R add(T x, U y)
{
    return x+y;
}

1
2
3
4
5

template<typename T, typename U>
auto add2(T x, U y) -> decltype(x+y)
{
    return x + y;
}

1
2
3
4
5

template<typename T, typename U>
auto add3(T x, U y)
{
    return x + y;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

// after c++11
auto w = add2<int, double>(1, 2.0);
if (std::is_same<decltype(w), double>::value)
{
    std::cout << "w is double: ";
}
std::cout << w << std::endl;

// after c++14
auto q = add3<double, int>(1.0, 2);
std::cout << "q: " << q << std::endl;

1
2

std::string lookup1();
std::string& lookup2();

1
2
3
4
5
6
7
8
9

std::string look_up_a_string_1()
{
    return lookup1();
}

std::string& look_up_a_string_2()
{
    return lookup2();
}

1
2
3
4
5
6
7
8

decltype(auto) look_up_a_string_1()
{
    return lookup1();
}
decltype(auto) look_up_a_string_2() 
{
    return lookup2();
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

#include <iostream>

template<typename T>
auto print_type_info(const T& t) 
{
    if constexpr (std::is_integral<T>::value) {
        return t + 1;
    } else {
        return t + 0.001;
    }
}

int main() 
{
    std::cout << print_type_info(5) << std::endl;
    std::cout << print_type_info(3.14) << std::endl;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

int print_type_info(const int& t)
{
    return t + 1;
}

double print_type_info(const double& t)
{
    return t + 0.001;
}

int main()
{
    std::cout << print_type_info(5) << std::endl;
    std::cout << print_type_info(3.14) << std::endl;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

#include <iostream>
#include <vector>
#include <algorithm>

int main()
{
    std::vector<int> vec = {1, 2, 3, 4};
    if (auto itr = std::find(vec.begin(), vec.end(), 3);
            itr != vec.end())
        *itr = 4;

    for (auto element : vec)
        std::cout << element << std::endl; // read only

    for (auto &element : vec) {
        element += 1; // writeable
    }

    for (auto element : vec)
        std::cout << element << std::endl; // read only
}

1
2

template class std::vector<bool>;           // 强行实例化
extern template class std::vector<double>;  // 不在该当前编译文件中实例化模板

1

std::vector<std::vector<int>> matrix;

1
2
3
4
5
6
7
8

template<bool T>
class MagicType
{
    bool magic = T;
};

// in main function:
std::vector<MagicType<(1>2)>> magic; // 合法, 但不建议写出这样的代码

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

template<typename T, typename U>
class MagicType
{
public:
    T dark;
    U magic;
};

// 不合法
template<typename T>
typedef MagicType<std::vector<T>, std::string> FakeDarkMagic;

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

typedef int (*process)(void *);
using NewProcess = int(*)(void *);

template<typename T>
using TrueDarkMagic = MagicType<std::vector<T>, std::string>;

int main() 
{
    TrueDarkMagic<bool> you;
}

1

template<typename... Ts> class Magic;

1

class Magic<int, std::vector<int>, std::map<std::string, std::vector<int>>> darkMagic;

1

template<typename Require, typename... Args> class Magic;

1

template<typename... Args> void printf(const std::string &str, Args... args);

1
2
3
4

template<typename... Ts> void magic(Ts... args) 
{
    std::cout << sizeof...(args) << std::endl; 
}

1
2
3

magic();        // 输出 0 
magic(1);       // 输出 1 
magic(1, "");   // 输出 2

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

#include <iostream>
template<typename T0>

void printf1(T0 value)
{
    std::cout << value << std::endl;
}

template<typename T, typename... Ts>
void printf1(T value, Ts... args)
{
    std::cout << value << std::endl;
    printf1(args...);
}

int main()
{
    printf1(1, 2, "123", 1.1);
    return 0;
}

1
2
3
4
5
6

template<typename T0, typename... T> 
void printf2(T0 t0, T... t)
{
    std::cout << t0 << std::endl;
    if constexpr (sizeof...(t) > 0) printf2(t...); 
}

1
2
3
4
5
6
7
8

template<typename T, typename... Ts>
auto printf3(T value, Ts... args)
{
    std::cout << value << std::endl;
    (void) std::initializer_list<T> {([&args] {
        std::cout << args << std::endl;
    }(), value)...};
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

#include <iostream>

template<typename ... T>

auto sum(T ... t)
{
    return (t + ...);
}

int main()
{
    std::cout << sum(1, 2, 3, 4, 5, 6, 7, 8, 9, 10) << std::endl;
}

1
2
3
4
5

template <typename T, typename U>
auto add(T t, U u)
{
    return t+u;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

template <typename T, int BufSize> 
class buffer_t
{
public:
    T& alloc();
    void free(T& item);

private:
    T data[BufSize];
}

buffer_t<int, 100> buf; // 100 作为模板参数

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

template <auto value> 
void foo() 
{
    std::cout << value << std::endl;
    return;
}

int main()
{
    foo<10>(); // value 被推导为 int 类型
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

#include <iostream>

class Base 
{
public:
    int value1;
    int value2;

    Base()
    {
        value1 = 1;
    }

    // 委托 Base() 构造函数
    Base(int value) : Base() 
    {
        value2 = value;
    }
};

int main() 
{
    Base b(2);
    std::cout << b.value1 << std::endl;
    std::cout << b.value2 << std::endl;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

#include <iostream> 

class Base 
{
public:
    int value1;
    int value2;

    Base() {value1 = 1;}
    // 委托 Base() 构造函数 value2 = value;
    Base(int value) : Base() {}
};

class Subclass : public Base 
{
public:
    // 继承构造
    using Base::Base;
};

int main()
{
    Subclass s(3);
    std::cout << s.value1 << std::endl;
    std::cout << s.value2 << std::endl;
}

1
2
3
4
5
6
7
8
9

struct Base
{
    virtual void foo();
};

struct SubClass: Base
{
    void foo();
};

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

struct Base 
{
    virtual void foo(int);
};

struct SubClass: Base 
{
    virtual void foo (int) override;  // 合法
    virtual void foo (float) override; // 不合法
};

1
2
3
4
5
6
7
8

struct Base
{
    virtual void foo() final;
};

struct SubClass1 final: Base { };       // 合法
struct SubClass2 : SubClass1 { };       // 非法, SubClass1 已 final
struct SubClass3: Base {void foo();};   // 非法, foo 已 final

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

class Magic
{
public:
    // 显式声明使用编译器生成的构造
    Magic() = default;

    // 显式声明拒绝编译器生成构造
    Magic& operator=(const Magic&) = delete;

    Magic(int magic_number);
}

1
2
3
4
5
6

enum class new_enum : unsigned int {
    value1,
    value2,
    value3 = 100,
    value4 = 100
};

1
2
3
4

if (new_enum::value3 == new_enum::value4)
{
    std::cout << "new_enum::value3 == new_enum::value4" << std::endl;
}

1
2
3
4
5
6
7
8

#include <iostream> 
template<typename T>
std::ostream& operator<<(
        typename std::enable_if<std::is_enum<T>::value, 
        std::ostream>::type& stream, const T& e)
{
    return stream << static_cast<typename std::underlying_type<T>::type>(e);
}

1

std::cout << new_enum::value3 << std::endl

1
2
3

[捕获列表](参数列表) mutable(可选) 异常属性 -> 返回类型 {
    // 函数体
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

void lambda_value_capture()
{
    int value = 1;
    auto copy_value = [value] {
        return value;
    };

    value = 100;
    auto stored_value = copy_value();
    std::cout << "stored_value = " << stored_value << std::endl; 

    // 这时, stored_value == 1, 而 value == 100.
    // 因为 copy_value 在创建时就保存了一份 value 的拷贝
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

void lambda_reference_capture() {
    int value = 1;
    auto copy_value = [&value] {
        return value;
    };

    value = 100;
    auto stored_value = copy_value();
    std::cout << "stored_value = " << stored_value << std::endl;
    // 这时, stored_value == 100, value == 100.
    // 因为 copy_value 保存的是引用
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

#include <iostream>
#include <memory> // std::make_unique
#include <utility> // std::move

void lambda_expression_capture() 
{
    auto important = std::make_unique<int>(1);
    auto add = [v1 = 1, v2 = std::move(important)](int x, int y) -> int {
        return x+y+v1+(*v2); 
    };
    std::cout << add(3,4) << std::endl;
}

1
2
3
4
5
6
7

auto add = [](auto x, auto y) 
{
    return x+y;
};

add(1, 2);
add(1.1, 2.2);

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

#include <iostream>

using foo = void(int); // 定义函数类型, using 的使用见上一节中的别名语法

// 定义在参数列表中的函数类型 foo 被视为退化后的函数指针类型 foo*
void functional(foo f) 
{
    f(1);   // 通过函数指针调用函数
}

int main()
{
    auto f = [](int value) {
        std::cout << value << std::endl;
    };

    functional(f);  // 传递闭包对象，隐式转换为 foo* 类型的函数指针值
    f(1);           // lambda 表达式调用

    return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

#include <functional>
#include <iostream>

int foo(int para)
{
    return para;
}

int main()
{
    // std::function 包装了一个返回值为 int, 参数为 int 的函数
    std::function<int(int)> func = foo;
    
    int important = 10;
    std::function<int(int)> func2 = [&](int value) -> int {
        return 1+value+important;
    };
    std::cout << func(10) << std::endl;
    std::cout << func2(10) << std::endl;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

int foo(int a, int b, int c)
{
    ;
}

int main()
{
    // 将参数 1,2 绑定到函数 foo 上，但是使用 std::placeholders::_1 来对第一个参数进行占位
    auto bindFoo = std::bind(foo, std::placeholders::_1, 1,2);

    // 这时调用 bindFoo 时，只需要提供第一个参数即可
    bindFoo(1);
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

class Foo
{
    const char*&& right = "this is a rvalue"; // 此处字符串字面量为右值
public:
    void bar()
    {
        right = "still rvalue"; // 此处字符串字面量为右值 
    }
};

int main()
{
    const char* const &left = "this is an lvalue"; // 此处字符串字面量为左值
}

1
2
3
4
5
6
7

std::vector<int> foo()
{
    std::vector<int> temp = {1, 2, 3, 4};
    return temp;
}

std::vector<int> v = foo();

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

#include <iostream>
#include <string>
void reference(std::string& str)
{
    std::cout << " 左值" << std::endl;
}

void reference(std::string&& str)
{
    std::cout << " 右值" << std::endl;
}

int main()
{
    std::string lv1 = "string,";        // lv1 是一个左值
    // std::string&& r1 = lv1;          // 非法, 右值引用不能引用左值
    std::string&& rv1 = std::move(lv1); // 合法, std::move 可以将左值转移为右值
    std::cout << rv1 << std::endl;      // string,

    const std::string& lv2 = lv1 + lv1; // 合法, 常量左值引用能够延长临时变量的生命周期
    // lv2 += "Test";                   // 非法, 常量引用无法被修改
    std::cout << lv2 << std::endl;      // string,string,

    std::string&& rv2 = lv1 + lv2;      // 合法, 右值引用延长临时对象生命周期
    rv2 += "Test";                      // 合法, 非常量引用能够修改临时变量
    std::cout << rv2 << std::endl;      // string,string,string,Test

    reference(rv2);                     // 输出左值 

    return 0;
}

1
2
3
4
5
6
7
8

#include <iostream>

int main()
{
    // int &a = std::move(1);           // 不合法，非常量左引用无法引用右值
    const int &b = std::move(1);        // 合法, 常量左引用允许引用右值
    std::cout << a << b << std::endl;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

void increase(int & v) 
{
    v++;
}

void foo()
{
    double s = 1;
    increase(s);
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47

#include <iostream> 

class A
{
public:
    int *pointer;
    A() : pointer(new int(1)) 
    {
        std::cout << " 构造" << pointer << std::endl;
    }

    A(A& a) : pointer(new int(*a.pointer))
    {
        std::cout << " 拷贝" << pointer << std::endl;
    } // 无意义的对象拷贝

    A(A&& a):pointer(a.pointer)
    {
        a.pointer = nullptr;
        std::cout << " 移动" << pointer << std::endl;
    }

    ~A()
    {
        std::cout << " 析构" << pointer << std::endl;
        delete pointer;
    }
};

// 防止编译器优化
A return_rvalue(bool test)
{
    A a,b;
    if(test) return a;  // 等价于 static_cast<A&&>(a);
    else return b;      // 等价于 static_cast<A&&>(b);
}

int main()
{
    A obj = return_rvalue(false);
    
    std::cout << "obj:" << std::endl;
    std::cout << obj.pointer << std::endl;
    std::cout << *obj.pointer << std::endl;

    return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

#include <iostream>     // std::cout
#include <utility>      // std::move 
#include <vector>       // std::vector
#include <string>       // std::string

int main() 
{
    std::string str = "Hello world.";
    std::vector<std::string> v;

    // 将使用 push_back(const T&), 即产生拷贝行为
    v.push_back(str);

    // 将输出 "str: Hello world."
    std::cout << "str: " << str << std::endl;
 
    // 将使用 push_back(const T&&), 不会出现拷贝行为
    // 而整个字符串会被移动到 vector 中，所以有时候 std::move 会用来减少拷贝出现的开销
    // 这步操作后, str 中的值会变为空
    v.push_back(std::move(str));

    // 将输出 "str: "
    std::cout << "str: " << str << std::endl;

    return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

void reference(int& v)
{
    std::cout << " 左值" << std::endl;
}

void reference(int&& v)
{
    std::cout << " 右值" << std::endl;
}

template <typename T> void pass(T&& v)
{
    std::cout << " 普通传参:";
    reference(v); // 始终调用 reference(int&)
}

int main()
{
    std::cout << " 传递右值:" << std::endl;
    pass(1); // 1 是右值, 但输出是左值

    std::cout << " 传递左值:" << std::endl;

    int l = 1;
    pass(l); // l 是左值, 输出左值

    return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

#include <iostream>
#include <utility>

void reference(int& v)
{
    std::cout << " 左值引用" << std::endl;
}

void reference(int&& v)
{
    std::cout << " 右值引用" << std::endl;
}

template <typename T>
void pass(T&& v)
{
    std::cout << "普通传参：";
    reference(v);

    std::cout << "std::move 传参";
    reference(std::move(v));

    std::cout << " std::forward 传参: ";
    reference(std::forward<T>(v));
    
    std::cout << " static_cast<T&&> 传参: ";
    reference(static_cast<T&&>(v));
}

int main()
{
    std::cout << " 传递右值:" << std::endl;
    pass(1);

    std::cout << " 传递左值:" << std::endl;
    int v = 1;
    pass(v);

    return 0;
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

传递右值:
                 普通传参: 左值引用
           std::move 传参: 右值引用
        std::forward 传参: 右值引用
    static_cast<T&&> 传参: 右值引用
传递左值:
                 普通传参: 左值引用
           std::move 传参: 右值引用
        std::forward 传参: 左值引用
    static_cast<T&&> 传参: 左值引用

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

template<typename _Tp>
constexpr _Tp&& forward(typename std::remove_reference<_Tp>::type& __t) noexcept 
{
    return static_cast<_Tp&&>(__t);
}

template<typename _Tp>
constexpr _Tp&& forward(typename std::remove_reference<_Tp>::type&& __t) noexcept
{
    static_assert(!std::is_lvalue_reference<_Tp>::value, 
            "template argument substituting _Tp is an lvalue reference type");
    return static_cast<_Tp&&>(__t);
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

std::vector<int> v;
std::cout << "size:" << v.size() << std::endl; // 输出 0 
std::cout << "capacity:" << v.capacity() << std::endl; // 输出 0

// 如下可看出 std::vector 的存储是自动管理的，按需自动扩张
// 但是如果空间不足，需要重新分配更多内存，而重分配内存通常是性能上有开销的操作
v.push_back(1);
v.push_back(2);
v.push_back(3);
std::cout << "size:" << v.size() << std::endl;          // 输出 3 
std::cout << "capacity:" << v.capacity() << std::endl;  // 输出 4

// 这里的自动扩张逻辑与 Golang 的 slice 很像
v.push_back(4);
v.push_back(5);
std::cout << "size:" << v.size() << std::endl;          // 输出 5
std::cout << "capacity:" << v.capacity() << std::endl;  // 输出 8

// 如下可看出容器虽然清空了元素，但是被清空元素的内存并没有归还
v.clear();
std::cout << "size:" << v.size() << std::endl;          // 输出 0
std::cout << "capacity:" << v.capacity() << std::endl;  // 输出 8

// 额外内存可通过 shrink_to_fit() 调用返回给系统 
v.shrink_to_fit();
std::cout << "size:" << v.size() << std::endl;          // 输出 0
std::cout << "capacity:" << v.capacity() << std::endl;  // 输出 0

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

std::array<int, 4> arr = {1, 2, 3, 4};
arr.empty(); // 检查容器是否为空
arr.size(); // 返回容纳的元素数

// 迭代器支持
for (auto &i : arr) {
    // ...
}

// 用 lambda 表达式排序
std::sort(arr.begin(), arr.end(), [](int a, int b) {
    return b < a;
});

// 数组大小参数必须是常量表达式
constexpr int len = 4;
std::array<int, len> arr = {1, 2, 3, 4};

// 非法, 不同于 C 风格数组，std::array 不会自动退化成 T*
// int *arr_p = arr;