目录
1. 字符指针
1.1常量字符串的修改
加上const解决问题
打印常量字符串
1.2数组存放的字符串
1.3例题:数组创建与常量池的区别
2. 指针数组
2.1字符指针数组
2.2整型指针数组
2.3使用3个一维数组,模拟实现一个二维数组
2.4例题:
3.数组指针
3.1 数组指针的定义
3.2arr 和 &arr 有什么区别？
3.3 数组指针的使用
使用数组指针访问并打印一维数组
在自定义函数内打印二维数组
二维数组接收
数组指针接收
4. 数组参数、指针参数
4.1 一维数组传参
总结:
4.2 二维数组传参
总结:
4.3 一级指针传参
4.4 二级指针传参
5.函数指针
创建和使用一个函数指针变量
阅读两段有趣的代码：
例题1. 0地址函数调用
例题2 函数声明
这篇文章我重新又总结了一遍,所以说总结的可能比第一次写的更深刻，欢迎博主们的来访与指点!
指针的基础概念知识:
1. 指针就是个变量，用来存放地址，地址唯一标识一块内存空间。
2. 指针的大小是固定的4/8个字节（32位平台/64位平台）。
3. 指针是有类型，指针的类型决定了指针的+-整数的步长，指针解引用操作的时候的权限。
1. 字符指针
#include<stdio.h>
int main()
{char ch = 'w';char* pc = &ch;//pc是字符指针return 0;}这段代码定义了一个字符变量 ch 并将其初始化为 ‘w’。然后定义了一个字符指针 pc，并将其初始化为 &ch，即 pc 指向 ch 的地址。
因为 ch是一个字符变量，其在内存中占据1个字节的空间。&ch 是 ch 的地址，即它指向 ch 在内存中的位置。pc变量的类型是字符指针，即它存储的是一个地址，该地址指向一个字符类型的变量。在这种情况下，pc 存储的是 ch 的地址，因此它指向 ch 变量的位置。
通过将字符指针指向字符变量的地址，可以使用指针来访问和修改该变量的值。例如，可以使用 *pc 来访问 ch 的值，即 *pc 的值为 w。可以使用 *pc = x 来修改 ch 的值，即将 ch 的值改为 x。
代码执行:
1.1常量字符串的修改
char* p = "abcdef"中，常量字符串"abcdef"这个表达式的值是首字符'a'的地址,本质是把字符串首字符‘a’的地址存储到p中去。
#include<stdio.h>
int main()
{char* p = "abcdef";//常量字符串，意思不是把字符串的值赋值给p，"abcdef\0"是7个字符
//所以说，占据7个字节的空间，不可能放到占用4个字节的指针变量p的空间里面去
//本质是把常量字符串首元素的地址--'a'的地址给了p*p = 'w';//程序报错的原因在于"abcdef"是常量字符串不能更改return 0;
}执行:
在 C 语言中，把字符串常量赋值给一个字符指针是合法的，但是对于指向字符串常量的指针，我们不能通过指针来修改其所指向的字符串的值，因为字符串常量是只读的，试图修改其值会导致未定义的行为。
如果将 p 声明为 char* 类型，那么指针指向的是一个字符串常量。因为字符串常量是只读的，所以试图通过 *p='w' 来修改字符串常量的值是非法的，这会导致编译错误。
加上const解决问题
寻求解决方法:
为了避免这种情况，可以使用 const 关键字修饰指针变量p，将其声明为指向常量的指针，即const char* 类型。这样一来，我们就不能通过指针来修改其所指向的字符串的值，这就保证了程序的正确性。
因此，将
p声明为 const char* 类型是为了避免试图修改字符串常量的值，从而保证程序的正确性。
这样它就会直接显示错误，提醒使用者这是个常量值不能被改掉。
打印常量字符串
实际上,只要拿到常量字符串"abcdef"的首字符地址也可以打印出整个字符串。
我们定义了一个字符指针
p，并将其初始化为指向字符串"abcdef"的首字符‘a’地址。然后，我们使用%s格式化字符来打印这个字符串。由于p指向字符串的首字符地址，因此当我们打印p时，它会从该地址开始输出，直到遇到终止字符'\0'为止，因此整个字符串"abcdef"都会被打印出来。
#include<stdio.h>
int main()
{char* p = "abcdef";printf("%s\n", p);return 0;
}
1.2数组存放的字符串
与常量字符串不同的是数组,数组的空间是可以修改的。
#include<stdio.h>
int main()
{char arr[] = "abcdef";char* p = arr;*p = 'w';printf("%s\n", arr);
}p指向的是数组的首元素，arr数组是可以修改的，数组在内存中是连续存放的,只要拿到首字符的地址,就会顺藤摸瓜一直打印到‘\0’停止。
执行:
1.3例题:数组创建与常量池的区别
图解:
#include <stdio.h>
int main()
{char str1[] = "hello bit.";char str2[] = "hello bit.";const char* str3 = "hello bit.";const char* str4 = "hello bit.";if (str1 == str2)printf("str1 and str2 are same\n");elseprintf("str1 and str2 are not same\n");if (str3 == str4)printf("str3 and str4 are same\n");elseprintf("str3 and str4 are not same\n");return 0;
}思路:
创建arr1和arr2两个数组，他们的地址肯定是不相同的，是两个变量。（以现在的知识储备,可以仔细想想，如果定义了两个数组，里面放的东西是一样的，修改其中一个arr1，另一个arr2也会跟着变吗，这样的设计肯定是不合理的,所以arr1和arr2的地址是不相同的。）
但是下面str3和str4是字符串常量 str3在创建的时候，会先去字符串常量池中找，看是不是有hello bit. 如果没有就创建，str4也是一样，但是它找到了，所以它就指向常量池中的这个字符串。
执行:
2. 指针数组
传送门-->指针和数组知识--http://t.csdn.cn/V3VqG
字符数组–存放字符的数组 char arr1[10];
整型数组–存放整型的数组 int arr2[5];
指针数组–存放的就是指针
存放字符指针的数组–字符指针数组 char* arr3[5];
存放整型指针的数组–整型指针数组 int*arr[6];
2.1字符指针数组
这样的代码表达的意思是:
int main()
{char* arr[] = { "abcdef","hehe","qwer" };int i = 0;for (i = 0; i < 3; i++){printf("%s\n", arr[i]);}return 0;
}对上述代码解析:
数组的每个元素是char*,能够存放的元素为字符指针，那每个元素只要存放一个字符的地址即可。数组的第一、二、三个元素都是char*，第一个元素它里面存放的是'abcdef\0 'a'的地址，第二个元素存放的是'hehe\0'里面第一个'h'的地址,第三个里面存放的是'qwer\0'这个'q'的地址。
它其实最终形成的这样一个形象是这样子:
arr[0]是‘a’的地址，arr[1]是‘h’的地址，arr[2]是‘q’的地址。那现在直接遍历这个数组,就能拿到这些字符串首字符的地址，就能够打印出来这些字符串。
2.2整型指针数组
int main() {int a = 10;int b = 20;int c = 30;int d = 40;int e = 50;int* arr[5] = { &a,&b,&c,&d,&e };int i = 0;for (i = 0; i < 5; i++){printf("%d ", *(arr[i]));}return 0;
}abcde五个变量不一定连续,把它们的首元素地址放在arr数组里面,数组在内存中是连续存放的
执行:
2.3使用3个一维数组,模拟实现一个二维数组
定义了三个整型数组arr1、arr2和arr3，分别存储了一组连续的整数。然后定义了一个整型指针数组arr，它包含了arr1、arr2和arr3三个数组的首元素地址。
for循环用于遍历arr数组中的每一个元素，即每个数组的首地址，然后在内层循环中，遍历了每个数组中的所有元素，并使用指针算术运算访问了每个元素的值并打印输出。
#include<stdio.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* arr[] = { arr1,arr2,arr3 };int i = 0;for (i = 0; i <3 ; i++){int j = 0;for (j = 0; j < 5; j++){//printf("%d ", arr[i][j]);printf("%d ", *(arr[i] + j));printf("%d ", *(*(arr+i) + j));}printf("\n");}return 0;
}*(*(arr+i) + j) == *(arr[i] + j) == arr[i][j] 三种写法等价
首元素地址加偏移量找到下标是这个元素的地址了,再解引用就找到此元素。
执行:
按自己的理解再写一个
图解:
用一个数组名表示首元素地址,把a，b，c放到arr中说明是把首元素地址存进去了,因为是个整型地址,所以是个整型指针,所以是int*arr[3]每个元素的类型是int*,本质是用一个指针数组,来管理3个int数组
#include<stdio.h>
int main()
{int a[] = { 1,2,3,4 };int b[] = { 2,3,4,5 };int c[] = { 3,4,5,6 };int* arr[3] = { a,b,c };int i = 0;for (i = 0; i < 3; i++){int j = 0;for (j = 0; j < 4; j++){printf("%d ", arr[i][j]);}printf("\n");}return 0;}执行:
arr[i][j]可写成*(arr[i]+j),一个整型指针(地址)加j向后偏移j个元素
2.4例题:
int main()
{
int* arr[3][3] = { 1 };int p = **arr;
printf("%p", p);}
3.数组指针
3.1 数组指针的定义
答案是：指针。
整形指针： int * pint ; 能够指向整形数据的指针。浮点型指针： float * pf ; 能够指向浮点型数据的指针。那数组指针应该是：能够指向数组的指针。
类比:
整型指针 -- 指向整型的指针int a = 10;
int* p = &a;
字符指针-指向字符的指针char ch = 'w';
char* pc = &ch;
数组指针–指向数组的指针
int arr[10] ;//数组
int (*pa)[10] = &arr;//取出的是数组的地址
char arr[10] -- char (*pc)[10] = &arr;
int*arr[5];-- int* (*pc ) [5] =&arr
int * p1 [ 10 ];int ( * p2 )[ 10 ];//p1, p2 分别是什么？答:int (*p2)[10];
p先和*结合，说明p是一个指针变量，然后指着指向的是一个大小为10个整型的数组。所以p是一个 指针，指向一个数组，叫数组指针,[]的优先级要高于*号的，所以必须加上（）来保证p先和*结合。
易错点:
int main()
{int a = 10;int* pa = &a;//1int arr[10] = { 1,2,3,4,5,6,7,8,9,10};int(*p)[10] = &arr;//2int(*p2)[10] = arr;//3}对上述代码总结:
1.*说明pa是指针,int说明pa指向的a变量是整型
2.&arr取出的是数组的地址,只有数组的地址才需要数组来接收,类型是int[10]3.arr是不能放进左边指针(类型是int[10])里面的,arr本身的类型是int*
3.2arr 和 &arr 有什么区别？
数组名绝大部分情况下是数组首元素的地址
但是有2个例外：
1. sizeof(数组名) - sizeof内部单独放一个数组名的时候，数组名表示的整个数组，计算得到的是数组的总大小
2. &arr - 这里的数组名表示整个数组，取出的是整个数组的地址,从地址值的角度来讲和数组首元素的地址是一样的，但是意义不一样
#include<stdio.h>
int main()
{int arr[10] = { 0 };//printf("%d\n", sizeof(arr));printf("%p\n", arr);//int * printf("%p\n", arr+1);//4printf("%p\n", &arr[0]);//int* printf("%p\n", &arr[0]+1);//4printf("%p\n", &arr);//int(*)[10]printf("%p\n", &arr+1);//40return 0;
}
上图可看出arr==&arr[0](地址值相等),也说明指针类型决定了指针+1到底加的是几,即为数组名是数组首元素地址,而&arr是整个数组的起始地址
我们已知的两种访问数组的方式:
int main()
{int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };int sz = sizeof(arr) / sizeof(arr[0]);int i = 0;//使用指针来访问int* p = arr;for (i = 0; i < sz; i++){printf("%d ", *(p + i));}printf("\n");//下标的形式访问数组for (i = 0; i < sz; i++){printf("%d ", arr[i]);}return 0;
}
3.3 数组指针的使用
使用数组指针访问并打印一维数组
理解:p == &arr,*p == *&arr,*p == arr
int main()
{int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };int sz = sizeof(arr) / sizeof(arr[0]);int (* p)[10] = &arr;//注意这个地方不是arr,&arr是整个数组的地址，所以要用数组指针接收int i = 0;//p --- &arr//*p --- *&arr//*p --- arr//虽然对，但是不推荐for (i = 0; i < sz; i++){printf("%d ", (*p)[i]);}printf("\n");//虽然对，但是不推荐for (i = 0; i < sz; i++){printf("%d ", *((*p) + i));}return 0;
}
(*p)+i的意思:下标为i的元素的地址,*((*p)+i)得到下标为i的元素。
以上两种写法均正确，但是不推荐。
在自定义函数内打印二维数组
二维数组接收
打印二维数组传参的时候可以形参用二维数组接收。
void print1(int arr[3][5], int r, int c) {int i = 0;for (i = 0; i < 3; i++){int j = 0;for (j = 0; j < 5; j++){printf("%d ", arr[i][j]);}printf("\n");} } int main() {int arr[3][5] = {1,2,3,4,5, 2,3,4,5,6, 3,4,5,6,7};/*二维数组的数组名，也表示首元素的地址二维数组的首元素是第一行首元素的地址就是第一行的地址,是一个一维数组的地址*///print1(arr, 3, 5);return 0; }
数组指针接收
也可以用数组指针接收，并遍历数组
二维数组的数组名，也表示首元素的地址
二维数组的首元素是第一行
首元素的地址就是第一行的地址,是一个一维数组的地址
void print(int(*arr)[5], int r, int c)
{int i = 0;for (i = 0; i < 3; i++){int j = 0;for (j = 0; j < 5; j++){//printf("%d ", *(*(arr + i) + j));printf("%d ", arr[i][j]);//printf("%d ", (*(arr + i))[j]);}printf("\n");}
}
int main()
{int arr[3][5] = {1,2,3,4,5, 2,3,4,5,6, 3,4,5,6,7};/*二维数组的数组名，也表示首元素的地址二维数组的首元素是第一行首元素的地址就是第一行的地址,是一个一维数组的地址*///print1(arr, 3, 5);return 0;
}*(*(arr + i) + j)--> arr 是二维数组的数组名，数组名是数组首元素地址，也就是二维数组的首元素第一行的地址,arr+i就是二维数组第 i 行地址，*(arr+i)得到二维数组第i行,也就是第i行的数组名,也就是arr[i],arr[i]数组名又相当于数组首元素地址，也就是第i行第一个元素的地址,即为&arr[i][0]
也就是说, *(arr+i) == arr[i] == &arr[i][0]
也可以这样写: printf("%d ", (*(arr + i))[j]);
(*(arr+i))[j])意思是访问完第i行之后再访问[j]列,可以写成arr[i][j]
易错点:
1.int arr[5];整型数组,数组有10个元素
2.int *parr1[10];指针数组,数组10个元素,每个元素都是int*类型的
3.int(*parr2)[10];parr2是数组指针,该指针指向一个数组,数组是10个元素,每个元素是int类型
4.int (*p)[10]=arr,如何强转?(int(*)[10])arr
5.int* p=&num,对p解引用的类型int
6.int(*p)[10]=&arr,&arr赋给p,p--arr,*p=*&arr=arr
7.int(*parr3[10])[5]
parr3是数组,数组中存放的指针，该指针指向的又是数组。
parr3和[10]结合说明parr3是数组,大小存10个元素,每个元素的类型是int(*)[5]，
可以理解为指针数组里面存放的是数组指针。
4. 数组参数、指针参数
4.1 一维数组传参
#include <stdio.h>
void test(int arr[])//1 ok
{}
void test(int arr[10])//2 ok
{}
void test(int* arr)//3 ok
{}
void test2(int* arr[20])//4 ok
{}
void test2(int** arr)//5 ok
{}
int main()
{int arr[10] = { 0 };int* arr2[20] = { 0 };test(arr);//&arr[0]test2(arr2);//&arr2[0]
}1.数组传参,形参部分写出数组,可以不指定大小,指定类型即可
2.数组传参,数组接收,大小指定10个元素,可以
总结:1和2是数组传参数数组接收
3.arr[10]数组10个元素,每个元素都是int,数组名表示首元素地址(整型的地址),就应该放到int指针里去 3.是数组传参指针接收
4.数组传参可以写成一样的,大小可以不写:int *arr[]
5.数组名表示首元素地址,每个元素都是int*的地址,是一级指针地址,可以用二级指针接收,不可以写成int* arr
总结:
一维数组传参，形参可以是数组，也可以是指针的当时形参是指针的时候，要注意类型
4.2 二维数组传参
void test(int arr[3][5])//1 ok
{}
void test(int arr[][])//2 no
{}
void test(int arr[][5])//3 ok
{}
//总结：二维数组传参，函数形参的设计只能省略第一个[]的数字。
//因为对一个二维数组，可以不知道有多少行，但是必须知道一行多少元素。//这样才方便计算
void test(int *arr)//4 no
{}
void test(int* arr[5])//5 no
{}
void test(int (*arr)[5])//6 ok
{}
void test(int **arr)//7 no
{}
int main()
{int arr[3][5] = {0};test(arr);
//二维数组传参，参数可以是指针，也可以是数组//如果是数组，行可以省略，但是列不能省略
//如果是指针，传过去的是第一行的地址，形参就应该是数组指针
}1.可以写成一模一样的
2.二维数组传参，函数形参的设计只能省略第一个[]的数字。因为对一个二维数组，可以不知道有多少行，但是必须知道一行多少元素,为什么❓
3.正确写法。
4.数组传参,要么写成数组要么写成指针,一级指针,不对，应该是数组指针
5.数组传参,形参要么写成数组,要么指针。但是这个形参是个数组,但又不是二维数组,能存指针但又不是指针。(指针数组)
6.数组前有(*arr)，说明是指针,指针指向的[]是数组,数组5个元素,每个元素是int(一行五个元素)
7.看传过来的类型是什么,二级指针是用来接收一级指针的地址的,而arr传的是第一行的地址
总结:
二维数组传参，参数可以是指针，也可以是数组
- 如果是数组，行可以省略，但是列不能省略
- 如果是指针，传过去的是第一行的地址，形参就应该是数组指针
对2.的解释
在许多编程语言中，对于二维数组（或者说是矩阵），通常需要知道每一行包含多少元素。这是因为二维数组在内存中通常是连续存储的，所以我们需要知道每行有多少元素来正确地在内存中定位元素。
例如，如果我们有一个二维数组，每行有
n个元素，那么第i行第j个元素在内存中的位置就是i * n + j。这种计算方式基于数组的第一个元素位置为0，以及数组的行和列都是从0开始计数。这就是为什么在声明和使用二维数组时，必须知道一行有多少元素的原因。如果你不知道每行的元素数，你就无法正确地在内存中定位到你要访问的元
素。
4.3 一级指针传参
#include <stdio.h>
void print(int *p, int sz)
{int i = 0;for(i=0; i<sz; i++){printf("%d\n", *(p+i));}
}
int main()
{int arr[10] = {1,2,3,4,5,6,7,8,9};int *p = arr;int sz = sizeof(arr)/sizeof(arr[0]);//一级指针p，传给函数print(p, sz);return 0;
}p是一级指针传参,一级指针接收即可
4.4 二级指针传参
#include <stdio.h>
void test(int** ptr)
{printf("num = %d\n", **ptr);
}
int main()
{int n = 10;int*p = &n;int **pp = &p;test(pp);//二级指针,指向了一级指针的地址test(&p);//一级指针地址return 0;
}二级指针传参，可以传一级指针地址，也可以传二级指针。
5.函数指针
类比:
整型指针–指向整型的指针int*
字符指针–指向字符的指针char*
数组指针–指向数组的指针int arr[10];
函数指针–指向函数的指针
数组: 数组名和&数组名是有区别的
函数:函数名和&函数名都是函数的地址，没有区别
int Add(int x,int y) {return x + y; } int main() {printf("%p\n", &Add);printf("%p\n", Add);return 0; }
可看到以上代码两种表示方法结果是一样的,函数没有什么首元素的地址,数组才有,所以函数指针用 & 和 不用& 结果都是一样的。
总结:&函数名和函数名都是函数的地址
创建和使用一个函数指针变量
int Add(int x, int y)
{return x + y;
}
int main()
{//pf就是函数指针int (* pf)(int, int) = Add;//函数的地址要存起来，就得放在【函数指针变量】中int ret1 = (*pf)(3, 5);int ret2 = Add(3, 5);int ret3 = pf(3, 5);printf("%d\n", ret1);printf("%d\n", ret2);printf("%d\n", ret3);return 0;
}pf是一个存放函数地址的指针变量 - 函数指针 ,和数组指针写法相似,注意:函数指针变量名是pf,不是*pf,*只是告诉我们pf是指针,,要用*pf一定要加(),否则*pf(2,3)，求其结果是*5
执行:
总结:pf(3,5) == (*pf)(3,5) ==Add(3,5)
阅读两段有趣的代码：
例题1. 0地址函数调用
int main()
{//代码1(*(void (*)())0)();return 0;}整体看下来，这样分析:
1. 将0强制类型转换为void (*)() 类型的函数指针
2. 这就意味着0地址处放着一个函数，函数没参数，返回类型是void
3. 调用0地址处的这个函数细致分析:
从0开始下手,0是整型int,若在(void(*)())放p,为void(*p)()说明是函数指针,(void(*)())0说明是把0强制转换成函数指针类型(0被当成一个地址,0地址,放的参数是无参,返回类型是void的函数)，
在前面加*,写成*(void(*)())0,说明对0地址做解引用操作,那个函数是无参的,所以最后面的括号写成()没有传任何参数
总结:该代码是一次函数调用,调用的0地址处的一个函数,首先代码中将0强制类型转换为类型void(*)()函数指针,然后去调用0地址处的函数--------来自《C陷阱和缺陷》
可用上述代码类比一下
例题2 函数声明
int main(){void(*signal(int, void(*)(int)))(int);return 0;
}从signal开始,*和signal没()一起,说明不是个指针,而signal括号包含两个参数类型,一个int,另一个是函数指针,说明signal第一个参数是整型，第二个为函数指针,函数除了函数名和参数外,还有返回类型,把函数名和参数类型删去,即为返回类型:void(*)(int)
虽然这样更容易理解,但这样写是错误的:void(*)(int)signal(int,void(*)(int));(只用于方便理解)
总结:
上述的代码是一个函数的声明
函数的名字是signalsignal函数的参数第一个是int类型，第二个是void(*)(int)类型的函数指针
该函数指针指向的函数参数是int，返回类型是void
signal函数的返回类型也是一个函数指针
该函数指针指向的函数参数是int，返回类型是void
为了看起来方便，可以用typedef重命名类型
typedef int* ptr_t;
typedef void(*pf_t)(int); //将void(*)(int)类型重新起个别名叫pf_t
所以可以写成这样:
pf_t signal(int, pf_t);
区别:
typedef void(*pf_t2)(int); //pf_t2是类型名
void(*pf)(int);//pf是函数指针变量的名字
接下来还有指针进阶(2)，上述文章如有错误欢迎大佬指针，感谢你的来访。
