C++ 11 for 循环和容器

Range-Based for 循环

C++为 for 提供 for range 的用法。对于 STL(vector/list/map)的遍历带来了极
大的书写便利。

（range for）语句遍历给定序列中的每个元素并对序列中的每个值执行某种操作，
其语法形式是：

for (declaration : expression)
    statement</code>
        

expression 部分是一个对象，必须是一个序列，比方说用花括号括起来的初始值
列表、数组或者 vector 或 string 等类型的对象。这些类型的共同特点是拥有能返回迭
代器的 begin 和 end 成员。
declaration 部分负责定义一个变量，该变量将被用于访问序列中的基础元素。每
次迭代，declaration 部分的变量会被初始化为 expression 部分的下一个元素值。确
保类型相容最简单的办法是使用 auto 类型说明符。

#include <iostream>
using namespace std;

int main(){
    int arr[10] = {1,2,3,4,5,6,7};
    for(auto &i: arr)
    {
        cout<<i<<endl;
    }
    string str = "china"; //OK
    char  str[] = "china"; //OK
    char  * str = "china"; //ERROR
    for(auto & ch: str)
    {
        cout<<ch<<endl;
    }
    return 0;
}

for STL

#include <iostream>
#include <vector>
using namespace std;

int main(){
    // 定义一个长度为10的数组，并初始化前7个元素为1, 2, 3, 4, 5, 6, 7，其余元素默认为0
    int arr[10] = {1, 2, 3, 4, 5, 6, 7};

    // 使用数组arr的首地址和尾地址（arr+10）初始化一个vector<int>，即vi
    // arr是数组的首地址，arr+10表示数组的尾地址（即数组最后一个元素的下一个地址）
    vector<int> vi(arr, arr + 10);

    // 定义一个vector<int>的迭代器it
    vector<int>::iterator it;

    // 使用迭代器遍历vector<int> vi
    for (it = vi.begin(); it != vi.end(); ++it) {
        // 输出迭代器指向的元素值，并换行
        cout << *it << endl;
    }


    for (auto & i : vi){
        i+=5;
    }
    for (auto i : vi){
        cout<<i<<endl;
    }
    return 0;
}

#include <iostream>
#include <map>
using namespace std;

int main(){
    // 定义一个map，键类型为int，值类型为string
    map<int, string> mis;

    // 向map中插入键值对
    mis[1] = "apple";  // 使用下标操作符插入键值对
    mis[2] = "banana"; // 使用下标操作符插入键值对
    mis.insert({0, "zero"}); // 使用insert函数插入键值对

    // 定义一个map<int, string>的迭代器it
    map<int, string>::iterator it;

    // 使用迭代器遍历map
    for (it = mis.begin(); it != mis.end(); ++it) {
        // 输出迭代器指向的键和值
        cout << it->first << " " << it->second << endl;
    }

    // 使用范围for循环遍历map
    for (auto & p : mis) {
        // 输出键和值
        cout << p.first << " " << p.second << endl;
    }
    return 0;
}

vector 初始化

std::vector 是 C++ 标准库中的一个动态数组容器，定义在 头文件中。
它提供了高效的随机访问和在末尾插入/删除元素的能力，
但在中间或开头插入/删除元素的效率较低。
std::vector 是动态大小的，可以根据需要自动调整其大小。

主要特点

动态数组：
std::vector 是一个动态数组，可以在运行时根据需要增长或缩小。
它支持高效的随机访问，时间复杂度为 O(1)。

高效的末尾操作：
在 std::vector 的末尾插入或删除元素的时间复杂度为 O(1)（平均情况）。

低效的中间或开头操作：
在 std::vector 的中间或开头插入或删除元素的时间复杂度为 O(n)，因为需要移动后续元素。

自动管理内存：
std::vector 自动管理内存，当元素被插入或删除时，它会自动调整其内部存储。

vector 初始化可以有多种方式，下面介绍几种常用的初始化方式。

#include <iostream>
#include <vector>

using namespace std;

int main()
{
    // 定义一个数组并初始化
    int arr[] = {1, 2, 3, 4, 5};
    // 以下是几种不同的方式来初始化一个vector<int>
    // 1. 声明一个空的vector<int>，不进行初始化
     vector<int> vi;
    // 2. 声明一个大小为5的vector<int>，默认初始化为0
     vector<int> vi(5);
    // 3. 声明一个大小为5的vector<int>，每个元素初始化为5
     vector<int> vi(5, 5);
    // 4. 使用数组arr的元素来初始化vector<int>
     vector<int> vi(arr, arr + 5);
    // 5. 使用初始化列表来初始化vector<int>
    vector<int> vi = {1, 2, 3, 4, 5};
    // 6. 使用初始化列表来初始化vector<int>，与上面的方式等价
    vector<int> vi{1, 2, 3, 4, 5};
    // 遍历并输出vector<int>中的元素
    for (auto i : vi) {
        cout << i << " ";
    }
    cout << endl;
    

    return 0;
}

list 初始化

std::list 是 C++ 标准库中的一个双向链表容器，定义在 头文件中。
它提供了高效的插入和删除操作，特别是在链表的任意位置进行插入和删除操作时，
时间复杂度为 O(1)。
然而，由于其链表的特性，
随机访问（即通过索引直接访问元素）的效率较低，时间复杂度为 O(n)。

主要特点
双向链表： 
    std::list 是一个双向链表，每个元素都包含指向前一个元素和后一个元素的指针。
    这使得在链表的任意位置进行插入和删除操作非常高效。

不支持随机访问：
    由于链表的特性，std::list 不支持通过索引直接访问元素，必须通过迭代器遍历链表。
    
高效的插入和删除：
    在链表的任意位置插入和删除元素的时间复杂度为 O(1)，前提是已经有了指向该位置的迭代器。

动态大小：
    std::list 可以根据需要动态增长或缩小，不需要预先分配固定大小的内存。

list 初始化可以有多种方式，下面介绍几种常用的初始化方式。

#include <iostream>
#include <list>

using namespace std;

int main()
{
    // 定义一个数组并初始化
    int arr[] = {1, 2, 3, 4, 5};

    // 以下是几种不同的方式来初始化一个list<int>

    // 1. 声明一个空的list<int>，不进行初始化
    // list<int> vi;

    // 2. 声明一个大小为5的list<int>，默认初始化为0
    // list<int> vi(5);

    // 3. 声明一个大小为5的list<int>，每个元素初始化为5
    // list<int> vi(5, 5);

    // 4. 使用数组arr的元素来初始化list<int>
    // list<int> vi(arr, arr + 5);

    // 5. 使用初始化列表来初始化list<int>
    // list<int> vi = {1, 2, 3, 4, 5};

    // 6. 使用初始化列表来初始化list<int>，与上面的方式等价
    list<int> vi{1, 2, 3, 4, 5};

    // 遍历并输出list<int>中的元素
    for (auto i : vi) {
        cout << i << " ";
    }
    cout << endl;

    return 0;
}

map 初始化

在C++中，std::map 是一个关联容器，用于存储键值对（key-value pairs），
其中键（key）是唯一的，并且每个键关联一个值（value）。
std::map 通常使用红黑树（Red-Black Tree）实现，
这使得查找、插入和删除操作的时间复杂度为 O(log n)。

主要特点
键值对存储：
std::map 存储键值对，其中键是唯一的。
键和值可以是任意类型，但键必须支持比较操作（通常是 < 操作符）。

有序存储：
std::map 中的元素是按照键的顺序自动排序的。

高效的查找、插入和删除：
由于使用红黑树实现，std::map 的查找、插入和删除操作的时间复杂度为 O(log n)。

动态大小：
std::map 可以根据需要动态增长或缩小，不需要预先分配固定大小的内存。

//todo map 初始化
#include <iostream>
#include <map>
#include <string>

using namespace std;

int main() {
    // 定义一个map<int, string>
    map<int, string> m;

    // 以下是几种不同的方式来初始化一个map<int, string>

    // 使用下标操作符插入元素
    // m[1] = "apple";
    // m[2] = "banana";
    // m[3] = "orange";
    // m[4] = "grape";

    // 使用insert方法和make_pair插入元素
    // m.insert(make_pair<int, string>(1, "apple"));
    // m.insert(make_pair<int, string>(2, "banana"));
    // m.insert(make_pair<int, string>(3, "orange"));
    // m.insert(make_pair<int, string>(4, "grape"));

    // 使用insert方法和map<int, string>::value_type插入元素
    // m.insert(map<int, string>::value_type(1, "apple"));
    // m.insert(map<int, string>::value_type(2, "banana"));
    // m.insert(map<int, string>::value_type(3, "orange"));
    // m.insert(map<int, string>::value_type(4, "grape"));

    // 使用初始化列表来初始化map<int, string>
    map<int, string> m2 = {
            {1, "apple"},
            {2, "banana"},
            {3, "orange"},
            {4, "grape"}
    };

    // 使用insert方法插入一个新元素
    m2.insert({5, "pear"});

    // 遍历并输出map<int, string>中的元素
    for (auto i : m2) {
        cout << i.first << " " << i.second << endl;
    }

    return 0;
}

initializer_list

std::initializer_list 是 C++11 引入的一种标准库类型，
用于表示一组相同类型的数据。它通常用于支持初始化列表的构造函数或其他函数参数。
std::initializer_list 可以方便地传递一组值，而不需要显式地使用数组或向量。

std::initializer_list 的元素是只读的，因此不需要在参数列表中显式地添加 const 关键字。
std::initializer_list 本身的设计就是为了提供一种只读的访问方式。

示例 1：使用 std::initializer_list 初始化容器

#include <iostream>
#include <vector>
#include <initializer_list>

int main() {
    std::vector<int> vec = {1, 2, 3, 4, 5};
    for (int i : vec) {
        std::cout << i << " ";
    }
    return 0;
}

示例 2：自定义类的构造函数使用 std::initializer_list

#include <iostream>
#include <initializer_list>

class MyClass {
public:
    MyClass(std::initializer_list<int> initList) {
        for (int value : initList) {
            std::cout << value << " ";
        }
    }
};

int main() {
    MyClass obj = {1, 2, 3, 4, 5};
    return 0;
}

示例 3：函数参数使用 std::initializer_list

#include <iostream>
#include <initializer_list>

void printList(std::initializer_list<int> list) {
    for (int value : list) {
        std::cout << value << " ";
    }
}

int main() {
    printList({1, 2, 3, 4, 5});
    return 0;
}

注意事项
std::initializer_list 是只读的，不能修改其内容。
std::initializer_list 的元素类型必须是相同的。
std::initializer_list 的构造函数是隐式的，因此可以直接用于初始化。

统一初始化风格

#include <iostream>
#include <vector>
using namespace std;
int main()
{
  int i = 3;
  int ii{3};
  int arr[] = {1,2,3};
  int arr2[] {1,2,3};
  vector<int> vi = {1,2,3};
  vector<int> vi2{1,2,3};
  return 0;
}