void 类型指针、const和指针、指针和数组，二级指针

一、void 类型指针

- void解释为“空虚，空隙”，而在C++语言中，void被翻译为“无类型”，相应的void*为“无类型指针”。
- void* 指针变量可以指向任意变量的内存空间，任何类型指针变量都可以转为void *。 
- int num = 10;
- void* p = #
- int* p_num = #
- void* p1 = p_num; (也是可以这样写的)
- 一般在函数里面用到void* | memset()
- 对应void*指针变量，不要解除引用操作（因为不知道取几个字节）,如果想要通过指针变量p获取num值，需要进行强制类型转换后才可以
- void* 可以保存任意类型的地址。（万能指针）。
- 主要作为函数的参数

二、const和指针

cosnt 表示常量，对const修饰的变量，我们是不能去修改他的值的
int const 和 const int没有什么区别，但是const和指针关联起来就有区别了

1. 第一种情况：const在 * 的左边 修饰的是 * （指针，不是指针变量） （ 地址指向内存数据 ）（* p1 只读的，p1可读可写）

const int* p1 = #
- 指针 p1 指向的是一块内存，指向的这个内存是不可修改的 （因为const修饰的是指针，不是指针变量，注意了注意了注意了！！！）；
- 这块地址的内存是不可以修改的，这一块地址的内存，我们是通过*p1解除引用去获取的，即*p1是不可以修改的；
- 但是本身的p1变量是可以修改的
- 也称常量指针（常量的指针）


const int a = 10;
因为a 是一个常量，所以我们要加上const修饰 （const 修饰的是这个类型）
const int* p = &a; 即表示这个地址里面的数据是常量，对应上； 

• 对应一块内存，修饰的这一块内存是一个常量
• 指针指向的（内存的）数据是一个常量，常量的指针，常指针

2. 第二种情况：cosnt 在 * 的右边，修饰的是p2，（ * p2可读可写，p2只读）

int* const p2 = # 
 - 这时候const修饰的就是p2变量（p2是一个指针变量，p2保存的是一个地址）
 - p2变量的值不可以修改；
 - 但是p2所指向的那一块内存的数据就可以修改 （*p2 解除引用）；

• 指针变量p2是一个常量，称为指针（类型的）常量 | 【类比 int 类型的常量等等】

3. 第三种情况：const 在 * 的左右两边，既修饰 * （指针类型， * 代表地址）也修饰指针变量（即 * p3只读，p3只读）

const int* const p3 = #

三、指针和数组

1. 一维数组名

#include <bits/stdc++.h>
using namespace std;

int main() {
	// 创建一个数组  5 * 4字节 
	int arr[5] = {10, 20, 30, 40, 50};
	// 数组名arr当成类型，用在sizeof()函数中，表示的是数组的总大小(内存大小)
	cout << sizeof (arr) << endl; 
	
	// 数组名可以作为地址，代表的是首元素的地址
	cout << arr << endl; // int * 类型 
	cout << arr + 1 << endl; // 指针运算，类型是int *型的，跨度 4 个字节
	
	cout << "arr[1] = " << arr[1] << endl;  
	cout << "*(arr + 1) = " << *(arr + 1) << endl;
	
	// arr[1] 展开 *(arr + 1) : []外边的值（arr)在 + 号的左边，[]里面的值（arr)在 + 号的右边
	cout << "1[arr] = " << 1[arr] << endl;
	cout << "*(1 + arr) = " << *(1 + arr) << endl; 
	
	// []是对*()的缩写
	for (int i = 0; i < sizeof(arr) / sizeof(arr[0]); ++i) {
		cout << arr[i] << endl;
		cout << i[arr] << endl;
		cout << *(arr + i) << endl; // 解除引用的方式 
	} 
	
	// 推导，数组名作为地址，是首元素的首地址
	// 数组名是这个数组的首元素首地址
	// &arr[0] == &*(arr + 0) == arr + 0 == arr 
	
	return 0;
} 

2. 指针在数组中的操作（略）

3. 指针数组（int类型的数组，double类型的数组，指针类型的数组）

指针数组本质是数组，数组中的每个元素都是指针类型。

需求：定义一个数组，存放4个变量的地址。
int* arr[4];

arr[0] = &num1;
arr[1] = &num2;
arr[2] = &num3;
arr[3] = &num4;

int* arr[4] = {&num1, &num2, &num3, &num4};

4. 数组指针（本质是指针）：指向数组的指针，这个指针指向一个数组的首地址

前面说到数组名是地址，数组名是数组首元素的首地址
而数组指针，存放的是数组首地址（这就是不一样的点，注意了！！！）
虽然数组的首地址和首元素首地址的值是相同的，但是二者的操作是不同的（值一样，类型不一样 char * 与 char **）;


- 对元素操作与对整个数组操作区分一下，想一想二维数组


例如：char a[4] 和 char (*pa)[4];
a是char 类型，a+1，a的值会实实在在的加1，而pa是char[4]类型的，pa+1，pa则会加4（整个数组整个数组的跳，[6]的话，pa + 1就会 + 6（数组大小））；
pa = &a，pa相当与二维数组的行指针，现在它指向a[4]的地址。；
不用想的太复杂，可以认为pa（数组指针）是二维数组的行指针，执行一维数组（列）的地址

char (*q)[4];
这是一个指针，指向长度为4的一维数组，即指向一个char[4]
存放的是一个数组的地址
大小为4字节

5. 二级指针：一个指针变量保存的是另外一个指针变量的地址值

int num = 10;
int* p = #

定义一个二级指针
int** q = &p;