C 二维数组和指针、函数指针、typedef等的一些笔记

char a[5][24] = {0};
printf("%p\r\n", a);
printf("%p\r\n", a[0]);
printf("%p\r\n", *a);
printf("%p\r\n", &a[0][0]);
printf("%d\r\n", sizeof(a));
printf("%d\r\n", sizeof(a[0]));
printf("%d\r\n", sizeof(*a));
printf("%d\r\n", sizeof(&a[0][0]));
printf("%d\r\n", sizeof(a[0][0]));

output:
0x7ffd4b518aa0
0x7ffd4b518aa0
0x7ffd4b518aa0
0x7ffd4b518aa0
120
24
24
8
1

int a[3][4] = {0,1,2,3,4,5,6,7,8,9,10,11};
int* *p = NULL;
p = (int**)a;       /* 不做强制类型转换会报错 */

int arr[5]={1，2，3，4，5};
int (*p1)[5] = &arr;
/*下面是错误的*/
int (*p2)[5] = arr;

int a[3][4] = {0,1,2,3,4,5,6,7,8,9,10,11};

void test(char* ptr) 
{
    printf("ptr_1: %p\r\n", ptr);
    ptr = (char*)malloc(1);
    printf("ptr_2: %p\r\n", ptr);
    *ptr = '2';
}
int main(void) {
    char *ptr2;
    printf("ptr2_1: %p\r\n", ptr2);
    test(ptr2);
    printf("ptr2_2: %p\r\n", ptr2);
    return 0;
}

// 输出：
ptr2_1: (nil)
ptr_1: (nil)
ptr_2: 0x1b8b020
ptr2_2: (nil)

// 原因：
只是把指针变量指向的NULL值传给了函数，函数内又重新申请了内存malloc，外面的指针变量还是指向NULL。

void test2(char* ptr) 
{
    printf("ptr_1: %p\r\n", ptr);
    *ptr = '2';
}

int main(void) {
    char *ptr2 = (char*)malloc(1);
    printf("ptr2_1: %p\r\n", ptr2);
    test2(ptr2);
    printf("ptr2_2: %p\r\n", ptr2);
    printf("test2: %s\r\n", ptr2);
    return 0;
}

// 输出：
ptr2_1: 0x1071020
ptr_1 : 0x1071020
ptr2_2: 0x1071020
test2: 2

// 原因：
传入了指针变量指向的地址，函数里设置了地址内存的值。外部的指针变量指向的还是之前的地址，但地址里已经有值了。

void test2(char** ptr) 
{
    printf("ptr_1: %p\r\n", *ptr);
    *ptr = (char*)malloc(1);
    printf("ptr_2: %p\r\n", *ptr);
}

int main(void) {
    char *ptr2 = (char*)malloc(1);
    printf("ptr2_1: %p\r\n", ptr2);
    test2(&ptr2);
    printf("ptr2_2: %p\r\n", ptr2);
    return 0;
}

// 输出：
ptr2_1: 0xc96020
ptr_1 : 0xc96020
ptr_2 : 0xc96040
ptr2_2: 0xc96040

int (*func)(int, int);
// 静态的函数指针
int (*const funcPtr)();
// 指向的函数的返回值是常量
const int(*funcPtr)

int (*func)(int, int);
int add(int x, int y){
    return x+y;
}
func = add; // 函数标识符代表函数的首地址
// 或
func = &add;

(*func)(1,2)
// 或
func(1,2)

int (*op[2])(int, int);
op[0] = add1;
op[1] = add2;
op[0](1, 2);

// 先定义函数指针类型；在通过指针类型定义函数指针数组
// 定义一种P的类型，并定义这种类型为指向某种函数的指针，这种函数以(int, int)为参数并返回int类型*/
typedef int (*P)(int, int);
P a[2] = {0};
a[0] = add;
a[0](1,2);

typedef <已有类型> <自定义别名>
如
typedef int INTE；
INTE a;
等价于
int a;

int *(*a[5])(int, char*);
// 变量名为a，直接用一个新别名pFun替换a就可以了：
typedef int *(*pFun)(int, char*); 
// 最简化版：
pFun a[5];

void (*b[10]) (void (*)());
// 变量名为b，先替换右边部分括号里的，pFunParam为别名一
typedef void (*pFunParam)();
// 再替换左边的变量b，pFunx为别名二
typedef void (*pFunx)(pFunParam);
// 最简化版：
pFunx b[10];

doube(*)() (*e)[9]; 
// 变量名为e，先替换左边部分，pFuny为别名一
typedef double(*pFuny)();
// 再替换右边的变量e，pFunParamy为别名二
typedef pFuny (*pFunParamy)[9];
// 最简化版：
pFunParamy e;

// 首先找到变量名func，外面有一对圆括号，
// 而且左边是一个*号，这说明func是一个指针；
// 然后跳出这个圆括号，先看右边，又遇到圆括号，
// 这说明 (*func)是一个函数，所以func是一个指向这类函数的指针，
// 即函数指针，这类函数具有int*类型的形参，返回值类型是int。
int (*func)(int *p);

const char* p = "123";
p ="abc";    // 正确
p[0] = '!';  // 错误 error: assignment of read-only location '*p'

char* const p = "123";
p[0] = '!';  // 正确
p ="abc";    // 错误 error: assignment of read-only variable 'p'