C++基础知识点吐血整理第二弹！！【新手必看！】

//1.数据类型 数组名【数组长度】
int arr[10];
//2.数据类型 数组名【数组长度】 = {值1，值2...}
int arr[3] = {1};        // 其中arr[0] == 1,arr[1]和arr[2]没有赋初值，会直接赋0
//3.数据类型 数组名【】 = {值1，值2...}

/*
注意：
想要初始化数组，必须可以知道它的初始长度！
*/

一维数组（线）

可以用循环来遍历

一维数组名的用途：**

//1.利用sizeof函数可以用来统计整个数组在内存中的长度（即整个数组占用内存空间的大小）
int arr[5] = {1,2,3,4,5};
sizeof(arr);        //sizeof(arr)等于5
sizeof(arr[0])      //sizeof(arr[i])可以得到某个元素的长度
                    //用sizeof(arr)除以sizeof(arr[i])就可以得到在数组中的元素个数
//2.可以获取数组在内存中的首地址
int arr[5] = {1,2,3,4,5};
cout<< arr << endl;     //此时就直接输出了数组的首地址（16进制地址编号）,输出arr等价于&arr[0]

数组名是常量，不能进行赋值操作

二维数组（面）

一般来说就是矩阵的形式，像这种类型的可以用双层循环来遍历

二维数组的声明方式：(先行后列)

//1.数据类型 数组名【行数】【列数】；
int arr1[2][3];
//2.数据类型 数组名【行数】【列数】 = {{数据1，数据2}，{数据3，数据4}}；
    /*
        第一个大括号内是第一行的数据
        第二个大括号内是第二行的数据
    */
int arr2[2][3] = {
    {1,2,3},
    {4,5,6}
};
//3.数据类型 数组名【行数】【列数】 = {数据1，数据2，数据3，数据4}；
int arr3[2][3] = {1,2,3,4,5,6};
    /*
        会自动根据给出的行数和列数来分配，先行后列，所以这个是三个三个的分，三个为一行，共两行。第一行是1 2 3 ，第二行是4 5 6 
    */
//4.数据类型 数组名【】【列数】 = {数据1，数据2，数据3}；
int arr4[][3] = {1,2,3,4,5,6};
    /*
        此时就算没有告诉这个二维数组有几行，但是可以知道它有几列，即一行有几个数字，也可知道有几行。第一行是1 2 3 ，第二行是4 5 6 
    */

arr0	arr0	arr0
arr1	arr1	arr1

第二种的声明方式最直接
可以省去行数，但是不可以省略列数

二维数组名的用途：

//1.可以查看所占用内存空间大小,利用sizeof
int arr[2][3] = {
    {1,2,3},
    {4,5,6}
};
cout << "二维数组占用内存空间为：" << sizeof(arr) << endl;
cout << "二维数组第一行占用内存为：" << sizeof(arr[0]) << endl;
cout << "二维数组第一个元素占用内存为：" << sizeof(arr[0][0]) << endl;

cout << "二维数组行数为：" << sizeof(arr) / sizeof(arr[0]) << endl;
cout << "二维数组列数为：" << sizeof(arr[0]) / sizeof(arr[0][0]) << endl;

//2.可以查看二维数组的首地址
cout << "二维数组的首地址为：" << (int)arr << endl;   
cout << "二维数组第一行首地址为：" << (int)arr[0] << endl;  
cout << "二维数组第一个元素的首地址为：" << (int)&arr[0][0] << endl;//会得到二维                                            数组的首地址，第一行数据的首地址，                                            第一个元素的首地址都是相同的

指针

基本知识点

指针其实就是地址编号

指针变量就是用来存储变量的地址 的变量

//1.定义指针
int a = 10;
int *p;  //创建了p指针
p = &a;  //此时指针p保存的就是变量a的地址

//2.使用指针（即 得到指针类型变量中的数据--可以对其进行修改）
*p  //这就取到了指针p所指空间内的内容

不管是什么数据类型：

在32位操作系统下，指针是占4个字节空间大小

在64位操作系统下，指针是占8个字节空间大小

空指针

空指针：指针变量指向内存编号为0的空间（即指针变量所指向内容的地址是0）

用途：初始化指针变量

空指针指向的内存不可以被访问！（这部分的内容被系统占用）

//创建空指针，指针变量p指向内存地址编号为0的空间
int *p = NULL;

//访问空指针，发现会报错，因为内存编号为0~255为系统占用内存，不允许用户访问
cout << *p << endl;

野指针

野指针：指针变量指向非法的内存空间（即指向的不是我申请的空间）

野指针其实是一种错误，在程序中应当避免野指针出现

//此时是随便找了写了一段内存地址，就好像你去宾馆开房，你买的是一间房，但是你拿着你的房卡想去随便开别的房间，这当然是没有权限的。同理现在这个你随便写的地址空间就没有去被访问的权限
int * p = (int *)0x1100;    //指针p就是野指针
cout << *p << endl;

总结：空指针和野指针都不是我们可以申请的空间，所以不能去访问，都会出错

coust修饰指针

coust修饰指针的三种情况：

1.coust修饰指针——常量指针

此时coust后面跟的是指针型变量

常量指针特点：
指针的指向可以直接修改，但是指针指向的值不能直接修改
（即指针指向的地址能变，但是地址中的内容不能操作。注意地址中的内容是不能直接修改，并不是必须和原来一样，如果是因为修改指向而导致的内容发生变化也是可以的。）

//eg.
int a = 10;
int b = 20;
coust int* p = &a;
//此时：
*p = 20;  //错误，指针指向的值不能改变
p = &b;   //正确，指针的指向可以改变

2.coust修饰常量——指针常量

此时coust后面跟的是普通变量

指针常量特点：
指针的指向不可以改，指针指向的值可以改

//eg.
int a = 10;
int b = 20;
int* coust p = &a;
//此时：
*p = 20;  //正确，指针指向的值可以改变
p = &b;   //错误，指针的指向不能改变

3.coust既修饰指针，又修饰常量

此时coust后面都跟（即包括普通变量和指针型变量）

指针常量特点：
指针的指向和指针指向的值都不可以改

//eg.
int a = 10;
int b = 20;
coust int* coust p = &a;
//此时：
*p = 20;  //错误，指针指向的值不能改变
p = &b;   //错误，指针的指向不能改变

数组和指针

数组名就是数组的首地址

int arr[] = {1,2,3,4,5};
int *p = arr;
cout << 数组的第一个元素是： << *p << endl;   //输出为1
p++;    //让指针向后偏移4个字节
cout << 数组的第二个元素是： << *p << endl;   //输出为2

谢谢大家对文章的认可~学习的快乐在于共同交流进步（咧嘴小菜得得

终于把这一部分的发出来咧（狗头保命~