C/C++基础----数组和引入指针

B.Bz

已于 2024-04-13 15:44:19 修改

阅读量997

点赞数 23

分类专栏： c/c++基础文章标签： c++ c语言算法

于 2024-04-13 00:10:21 首次发布

本文链接：https://blog.csdn.net/bjsyc123456/article/details/137696985

版权

c/c++基础专栏收录该内容

6 篇文章 0 订阅

订阅专栏

数组

数组的定义

语法：

类型 变量名[数组大小] = {数组内容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前面要加个&，因为要取出地址来，供下一层操作
所以到这里我们也明白了，为什么之前原生数组用下标取值，越界不报错，取出了奇奇怪怪的值，是因为内存地址是连续的，取到了电脑中下一个内存中的值，这个值我们谁也无法确定。
- 打印示例：
- 根据两次打印我们可以看出，内存地址是连续的，下标越界确实值不可预知。