---
# System prepended metadata

title: array and vector

---

# array and vector
---
* array
    1. 宣告
        ```cpp
        int arr[505]; // arr是陣列名稱，陣列儲存的資列形別是int
        ```
    2. 初始化
        ```cpp
        // 方法一
        int arr[50];
        arr[0] = 0;
        arr[1] = 1;
        arr[2] = 2;

        // 方法二
        int arr1[50] = {0, 1, 2};

        // 方法三
        int arr2[50] {0, 1, 2};
        
        // 全部初始為0
        int arr3[50] {};

        // ERROR!!
        int arr3[50];
        arr3 = {0, 1, 2};
        ```
        > [!WARNING]
        > ```cpp
        > int arr[50]; //沒有初始化數值，arr[0]可能是奇怪的數字
        > int arr1[50] = {1}; //arr[0] = 1, 剩下的數字初!始!為!0!
        > ```

    3. 遍歷array
        `arr[0] = 1, arr[1] = 2, arr[2] = 3.....`
        
        ```cpp
        int arr[50];
        for(int i = 0; i < 50; i++) {
            arr[i] = i + 1;
        }
        ```
        
* vector
    比較： 可以增加刪減空間
    1. 宣告
        ```cpp
        vector<int> v;    
        // v 稱作容器（想成裝資料），int是儲存內容的資料型別
        // 此處空間是零
        ```
        
    2. 基本涵式
        ```cpp
        vector<int> v;
        
        // v.empty() 看vector是不是空的
        if(v.empty()) // 相當於v.size() == 0
            cout << "I have a empty vector" << endl;
            
        // v.size(); 看vector的大小       
        cout << "My vector have the size " << v.size() << endl; 
        
        // 在容器尾端，加入一個值（多開一個空間）
        v.push_back(3);
        ```
    4. 初始化
        ```cpp
        vector<int> v(10); 
        // 有點類似 int v[10] = {};
        // 容器v初始十個空間，並給初始值0
        // v.size() 等於 10
        
        
        //v1初始四個空間，值為5，等同於 vector<int> v1 = {5, 5, 5, 5};
        vector<int> v1(4, 5);
        
        vector<int> v2 = {0, 1, 2};
        vector<int> v3 {0, 1, 2};
        // v.size() 等於 3
        
        
        vector<int> v4;
        //初始v4從1 ~ 10
        for(int i = 1; i <= 10; i++) {
            v4.push_back(i);
        }
        
        ```
        
    5. vector取值
        ```cpp
        vector<int> v = {1, 2, 3};
        
        //輸出第一個值
        cout << v[0] << endl;
        cout << v.at(0) << endl;
        
        
        // v[3] 應該不存在，但理論上還是會輸出值
        cout << v[3] << endl;
        
        // 和v[3]不同的是，他會跑出error訊息
        cout << v.at(3) << endl;
        ```
        
    6. 遍歷vector
        ```cpp
        vector<int> v = {1, 2, 3, 4, 5, 6, 7};
        
        for(int i = 0; i < 7; i++)
            cout << v[i] << endl;
        
        for(int i = 0; i < v.size(); i++) // v.size() = 7
            cout << v[i] << endl;
        ```

* 二維陣列
    1. 宣告
        ```cpp
        int arr[2][3];
        // 宣告兩個空間是三的陣列
        ```
    2. 初始化
        ```cpp
        int arr[2][3] = {{1, 2, 3}, {4, 5, 6}};
        
        // 也可以寫成這樣
        int arr1[2][3] = {
            {1, 2, 3},
            {4, 5, 6}
        };
        ```
    3. 遍歷
        ```cpp
        int arr[2][3] {{1, 2, 3}, {4, 5, 6}};
        for(int i = 0; i < 2; i++) {
            for(int j = 0; j < 3; j++) {
                // cout << i << " " << j << endl;
                cout << arr[i][j] << " ";
            }
            cout << endl;
        }
        ```
        注意兩層迴圈的$i$, $j$
        | $i$     | $j$     |         | 
        | ------- | ------- | ------- |
        | $i = 0$ | $j = 0$ | 
        |         | $j = 1$ | 第一個陣列的第2個數值
        |         | $j = 2$ |
        | $i = 1$ | $j = 0$ |
        |         | $j = 1$ |
        |         | $j = 2$ |

* 二維vector
    1. 宣告
        也就是宣告一個vector容器，裡面裝的東西都是一個vector<int>的容器
        ```cpp
        vector<vector<int> > v;
        ``` 
    2. 初始
        ```cpp
        // 通常不會用到拉
        vector<vector<int> > v = {{1, 2},{3, 4},{5,6}};
        
        vector<vector<int> > v1 (2, vector<int>(3, 4));
        // 比較 vector<int> v1(10, 5) 5為初始的值
        // 這邊初始的值是 vector容器 
        
        v1.assign(2, vector<int>(3, 4));
        
        vector<int> v2
        // 上方程式碼相當於
        for(int i = 0; i < 2; i++) {
            vector<int> add(3, 4);
            v2.push_back(add); // push_back一個容器酷吧
        }
        ```
        
    3. vector使用範例
        ```cpp
        int t = 0;
        vector<vector<int> > v;
        for(int i = 0; i < 2; i++) {
            vector<int> add;
            for(int j = 0; j < 3; j++) {
                add.push_back(t);
                t++;
            }
            v.push_back(add);
        }
        ```
        
        以上相當於
        ```cpp
        vector<vector<int> > v = {
            {0, 1, 2},
            {3, 4, 5}
        };
        ```
