数组

数组的定义

• 语法：

  类型 变量名[数组大小] = {数组内容1,数组内容2};
  int array[5] = {1,2,3,4,5};
  

• 代码

  int main(){
      // 定义数组，大小不写，数组内默认有多少元素大小就为多少
      int array_a[] = {1, 2, 3, 4, 5, 6};
      // 定义数组长度为5，存放了5个元素
      int array_b[5] = {1, 2, 3, 4, 5};
      return 0;
  }
  

---

数组的循环

第一种for循环

• 使用sizeof获取的数组大小为内存中的大小，int占4个字节，6个int占24个字节
• 求数组元素中的个数：sizeof(数组) / sizeof(数组内的元素类型)

  #include <iostream>
  
  using namespace std;
  
  int main() {
      int array_a[] = {1, 2, 3, 4, 5, 6};
      cout << "数组的大小：" << sizeof(array_a) << endl;
      cout << "数组中元素的个数：" << sizeof(array_a) / sizeof(int) << endl;
      int array_length = sizeof(array_a) / sizeof(int);
      for (int i = 0; i < array_length; i++) {
          cout << array_a[i] << endl;
      }
     	return 0;
  }
  
  

  

第二种for循环

• 语法

  for (数组中元素类型 临时变量: 数组){
  	// 操作的代码
  	i为每次遍历元组中的元素
  }
  

• 代码

  #include <iostream>
  
  using namespace std;
  
  int main() {
      int array_a[] = {1, 2, 3, 4, 5, 6};
      for (int i: array_a) {
          cout << i << endl;
      }
      return 0;
  }
  
  

  

---

包装数组

使用包装数组的原因:

• 使用包装数组是因为我们原生的数组不能动态的往数组添加元素，甚至数组的长度还需要我们来计算得出

• 原生数组下标越界后不报错，这导致我们程序写错时也不容易找出错误在哪

• 包装数组的意思就是非c++原生的数组，而是在原数组之上增加了其他方法和操作的功能的包装的数组

• 原生数组下标越界展示：

  int array[] = {1, 2, 3, 4};
  cout << array[4] << endl;
  

  

• 根据上面结果看出下标越界并不报错，而是打印出来一些…怪异的东西

std::array

• 语法：

  • 需要导入#include <array>
  • array.size() 返回数组长度
  • array.at(下标) 返回该下标元素，下标越界会报错

  #include <array>
  std::array<数组中元素的类型,数组的长度> 数组变量名 = {元素1,元素2...};
  // 返回数组的长度
  数组变量名.size() 
  // 根据下标取值
  数组变量名.at(下标)
  

• 代码：

  #include <iostream>
  #include <array>
  
  using namespace std;
  
  int main() {
      array<int, 5> array_a = {1, 2, 3, 4, 5};
      // 数组的长度
      cout << "array_a的长度为：" << array_a.size() << endl;
      // 遍历打印
      for (int i = 0; i < array_a.size(); i++) {
          cout << array_a.at(i) << endl;
      }
      return 0;
  }
  
  

  

• std::array使用at()方法获取元素下标越界

  • 直接抛出异常
  • tips: 使用std::array用 array[下标]取值的方式还是会出现和原生数组一样的情况

  #include <iostream>
  #include <array>
  
  using namespace std;
  
  int main() {
      array<int, 5> array_a = {1, 2, 3, 4, 5};
      // 数组的长度
      cout << "array_a的长度为：" << array_a.size() << endl;
      cout << "第五个个元素" << array_a.at(5) << endl;
      return 0;
  }
  

  

std::vector

• 语法：

  #include <vector>
  // 任意元素个数
  std::vector<数组中元素的类型> 数组变量名 = {元素1,元素2...};
  // 指定元素个数
  std::vector<数组中元素的类型> 数组变量名(指定的元素个数);
  // 返回数组的长度
  数组变量名.size() 
  // 根据下标取值
  数组变量名.at(下标)
  

• 代码：

  #include <iostream>
  #include <vector>
  
  using namespace std;
  
  int main() {
      vector<int> array_a = {1, 2, 3, 4, 5};
      for (int i = 0; i < array_a.size(); i++) {
          cout << array_a.at(i) << endl;
      }
      return 0;
  }
  

• vector的其他一些方法：

方法名	作用
push_back(要添加的值)	在数组的末尾添加一个元素
at(下标)	访问数组中该下标的元素
size()	返回数组的长度
clear()	清空数组中的元素
pop_back()	删除数组中末尾的一个值（没有返回值）
erase(迭代器指针 + 要删除的下标下的元素);	删除数组中指定下标的元素

• 示例：

  #include <iostream>
  #include <vector>
  
  using namespace std;
  
  int main() {
      vector<int> array_a = {1, 2, 3, 4, 5};
      cout << "当前数组元素：";
      for (int &i: array_a) {
          cout << i;
      }
      cout << endl;
      cout << "数组中在最后面添加了一个6！！" << endl;
      array_a.push_back(6);
      cout << "当前数组元素：";
      for (int &i: array_a) {
          cout << i;
      }
      cout << endl;
  
      cout << "数组取下标为0的值：" << array_a.at(0) << endl;
      cout << "数组取下标为1的值：" << array_a.at(1) << endl;
      cout << "当前数组的长度：" << array_a.size() << endl;
      cout << "数组中在最后删除了一个元素！！" << endl;
      array_a.pop_back();
      cout << "当前数组元素：";
      for (int &i: array_a) {
          cout << i;
      }
      cout << endl;
      cout << "数组中在下标为1的位置删除了一个元素！！" << endl;
      array_a.erase(array_a.begin() + 1);
      cout << "当前数组元素：";
      for (int &i: array_a) {
          cout << i;
      }
      cout << endl;
      // 迭代器打印
      for (auto i = array_a.begin(); i != array_a.end(); i++) {
          cout << *i << endl;
      }
      cout << "清空了数组！！" << endl;
      array_a.clear();
      cout << "当前数组长度：" << array_a.size() << endl;
      return 0;
  }
  

  

std:array和std::vector的区别

• 相同点：
  • at方法根据下标取值取不到都会抛出异常，使用下标取值都和原生数组一样
  • at()、size()方法用法一样
• 不同点
  • vector可以动态添加或删除数组中的值；array数组是固定的值，不能修改。
  • vector的每个元素的内存不是连续的，是动态分配的地址，而array和原生数组一样内的元素内存地址是连续的。这也就决定了vector会比原生和array的数组操作起来更耗时。
  • vector可以使用迭代器来循环

---

多维数组(数组嵌套)

• 语法：

  数组中元素的类型 数组变量名[第一层数组中的元素个数][第二层数组中的元素个数] = {
  	{元素1,元素2},{元素1,元素2}
  }
  

• 使用两次for循环来打印出数组中的每个元素

  #include <iostream>
  
  using namespace std;
  
  int main() {
      int array_a[2][2] = {{1, 2},
                           {2, 4}};
      // 循环两次
      for (int i = 0; i < 2; i++) {
      	// 每次循环再循环两次
          for (int j = 0; j < 2; j++) {
          	// 数组[第一层的下标][第二层的下标]取出数据
              cout << array_a[i][j] << endl;
          }
      }
  	return 0;
  }
  

第二种for循环遍历二维数组（引入指针）

• 代码：

  • auto类型为自动识别类型

  #include <iostream>
  
  using namespace std;
  
  int main() {
      int array_a[2][2] = {{1, 2},
                           {3, 4}};
      for (auto &i: array_a) {
          for (int j: i) {
              cout << j << endl;
          }
      }
  }
  

  

---

引入指针

• 其实c++中就是在操作内存，直接打印数组就是打印该数组第一个元素的内存地址。

  int array_a[2][2] = {{1, 2},
                       {3, 4}};
  cout << array_a << endl;
  

  

• 所有的变量在内存中都有地址

  • 使用&变量名取出变量的内存地址
  • 把内存地址赋值给 类型 * 变量名的一个变量
  • 这个变量被称为指针类型
  • 变量取出来的地址，该变量是什么类型指针就要是什么类型
  • 例如char a = 'a'; 那么char* p_a = &a;

  int a = 10;
  int *p_a = &a;
  cout << &a << endl;
  cout << p_a << endl;
  

  

• 所以之前二维数组打印时，第一层取出的i前面要加个&，因为要取出地址来，供下一层操作

• 所以到这里我们也明白了，为什么之前原生数组用下标取值，越界不报错，取出了奇奇怪怪的值，是因为内存地址是连续的，取到了电脑中下一个内存中的值，这个值我们谁也无法确定。

  • 打印示例：
    
    

  • 根据两次打印我们可以看出，内存地址是连续的，下标越界确实值不可预知。