const指针和void* 指针

3.2.2 const指针和void* 指针

（1）const 指针

int * const ptr const 修饰的是 ptr，而不是 int。表示指针本身是一个常量，不能被重新赋值指向其他对象

const int *ptr const 修饰的是 int，而不是 ptr。这表示指针指向的对象是一个常量，即不能通过该指针修改所指向的对象的值

int x = 10;
int y = 20;
int * const ptr = &x; // 定义一个指向整数的常量指针，指向变量 x
*ptr = 15; // 可以通过指针修改 x 的值
// ptr = &y; // 错误！指针是常量，不能重新赋值指向其他对象

int x = 10;
const int *ptr = &x; // 定义一个指向常量整数的指针
// *ptr = 15; // 错误！不能通过指针修改所指向的常量整数的值
x = 15; // 可以直接修改 x 的值

（2）void*指针

Void 类型的指针可以接受任意类型的地址； void 类型的指针不可以解引用，因为不知道指针类型；**

直接取值是不允许的。如果需要取值，必须转换为具体类型指针。

int value{ 5 };
void* voidPtr{ &value };

// std::cout << *voidPtr << '\n'; // 非法: 不允许void指针直接取值

int* intPtr{ static_cast<int*>(voidPtr) }; // 但可以转为int类型指针

std::cout << *intPtr << '\n'; // 最后通过int指针取值，输出结果为5

3.2.3 数组指针和指针数组

在区分指针数组和数组指针的区别一定要记住：数组名表示数组首地址，&arr一定要数组指针表示

int* parr[]：[] 的优先级比* 高，int* parr[] 是数组指针（也就是说先跟[]结合所以是个数组）；

#include <stdio.h>
#include <string.h>
int main() {
    int arr1[] = {1, 2, 3, 4, 5};
    int arr2[] = {2, 3, 4, 5, 6};
    int arr3[] = {3, 4, 5, 6, 7};
    int* parr[] = {arr1, arr2, arr3};
    for(int i = 0; i< 3; i++) {
        for (int j = 0; j < 5; j++) {
            printf("%d ", *(parr[i] + j));
        }
        printf("\n");
    }
    return 0;
}

Int (*p) arr[10], 先跟指针结合，所以是指针数组；

#include <stdio.h>
#include <string.h>
int main() {
    char* arr[5];;
    char* (*pa)[5]  = &arr;
    
    int arr2[10] = {10};
    int (*pa2)[10] = &arr2;
    return 0;
}
 

示例代码：

#include <stdio.h>
#include <string.h>

int Add(int x, int y)
{
    return x+y;
}

int Sub(int x, int y)
{
    return x-y;
}

int Mul(int x, int y)
{
    return x*y;
}

int Div(int x, int y)
{
    return x/y;
}


int main() {
    int (*pa)(int, int) = Add;//函数指针
    int(*parr[4])(int, int) = {Add, Sub, Mul, Div};
    for(int i = 0; i< 4; i++){
        printf("%d\n", parr[i](2, 3));
    }
    return 0;
}