一、字符指针

1.指针就是个变量，用来存放地址，地址唯一标识一块内存空间。

2.指针的大小是固定的4/8个字节(32位平台/64位平台)。

3.指针是有类型，指针的类型决定了指针的±整数的步长，指针解引用操作的时候的权限。

4.指针的运算。

1.字符指针示例

#includeint main() {  char ch = 'w';  char* pc = &ch;//pc就是字符指针  char* p = "abcdef";//是把字符串首字符的地址放在p中;这里abcdef是常量字符串不能修改  *p = 'w';//这种是erro常量字符串不可被修改  //abcdef这是7个字节了而32平台下字符指针是4个字节所以放不下  char arr[] = "abcdef";  char* p = arr;//p指向的是数组的首元素arr数组是可以修改的  *p = 'w';  printf("%s", arr);  return 0; }

2.字符指针例题

#includeint main() {  char str1[] = "hello word.";  char str2[] = "hello word.";  const char* str3 = "hello word.";  const char* str4 = "hello word.";  if (str1 == str2)  {  printf("str1 and str2 are same\n");  }  else  {  printf("str1 and str2 are not same\n");  }  if (str3 == str4)  {  printf("str3 and str4 are same\n");  }  else  {  printf("str3 and str4 are not same\n");  }  return 0; }

答案

解析：因为str1 str2分别是两个不同的空间中hello word.的首元素地址，所以他们的地址肯定也不同所以st1!=str2;假设hello word放在地址0x0012ff40,str3和str4都指向这个地址所以相同，但是&str3!=&str4因为取到的地址是两个不同空间的地址所以就不同了

二、指针数组

对指针数组来说，首先它是一个数组，数组的元素都是指针，也就是说该数组存储的是指针，数组占多少个字节由数组本身决定；

对于语句“intp1[5]”，因为“[]”的优先级要比“”要高，所以 p1 先与“[]”结合，构成一个数组的定义，数组名为 p1，而“int*”修饰的是数组的内容，即数组的每个元素。也就是说，该数组包含 5 个指向 int 类型数据的指针，如图 1 所示，因此，它是一个指针数组。

指针数组 - 是数组 - 是一种存放指针的数组

1.示例一：

下列代码就是一个指针数组

#includeint main() {  char* arr[] = { "abcdef","hehe","qwer" };  int i = 0;  for (i = 0; i < 3; i++)  {  printf("%s\n",arr[i]);  }  return 0; }

2.示例二

#includeint main() {  int arr1[] = {1,2,3,4,5};  int arr2[] = {6,7,8,9,3};  int arr3[] = { 3,4,5,6,7 };  //arr是一个存放整形指针的数组  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("\n");  }  return 0; }

三、数组指针

对数组指针来说，首先它是一个指针，它指向一个数组，也就是说它是指向数组的指针，在 32 位系统下永远占 4 字节，至于它指向的数组占多少字节，这个不能够确定，要看具体情况。

数组指针 - 是指针 - 是一种指向数组的指针 - 存放的是数组的地址

1.示例一

#includeint main() {  int arr[5];  int(*p)[5] = &arr;  return 0; }

“()”的优先级比“[]”高，“*”号和 p 构成一个指针的定义，指针变量名为 p而 int 修饰的是数组的内容，即数组的每个元素。也就是说，p 是一个指针，它指向一个包含 5 个 int 类型数据的数组

2.示例二

#includeint 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;  int i = 0;  //p --- &arr  //*p --- *&arr  //*p --- arr  for (i = 0; i < sz; i++)  {  printf("%d ", *((*p) + i));  printf("%d ", (*p)[i]);  }  return 0; }

四、判断指针数组or数组指针

解析：第一个是整型数组；第二个是指针数组；第三个是数组指针；而第四个parr3是数组，数组中存放的指针，该指针指向的又是数组；也就是说parr3是一个可以存放10个元素的数组，每个元素是一个指针可以指向另一个数组（这个数组是5个元素，每个元素都是int 类型）所以第四个是一个可以存放数组指针的数组

五、数组传参 、指针参数

1.一维数组的传参

（1）.形参为数组

#includevoid print(int arr[10],int sz) {  int i = 0;  for (i = 0; i < sz; i++)  {  printf("%d ", arr[i]);  } } int main() {  int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };  int sz = sizeof(arr) / sizeof(arr[0]);  print(arr, sz);  return 0; }

（2）.形参为指针（一级指针传参）

当一个函数的参数部分为[级指针的时候，函数能接收什么参数

int a;

print(&a，10);

intpl = &a;

print(p1，10);

int arr[10];

print(arr，10);*

#includevoid print(int* str, int sz) {  int i = 0;  for (i = 0; i < sz; i++)  {  printf("%d ", *(str+i));  } } int main() {  int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };  int sz = sizeof(arr) / sizeof(arr[0]);  print(arr, sz);  return 0; }

2.二维数组的传参

参数可以是指针，也可以是数组如果是数组，行可以省略，但是列不能省略

如果是指针，传过去的是第一行的地址，形参就应该是数组指针

（1）.形参为数组

#includevoid print(int arr[3][5], int row, int col) {  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 };  print(arr, 3, 5);  return 0; }

（2）.形参为指针

二维数组的数组名，也表示首元素的地址

二维数组的首元素是第一行

首元素的地址就是第一行的地址，是一个一维数组的地址

*(arr+0) - arr[0][0]

#includevoid print(int (*arr)[5], int row, int col) {  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 };  print(arr, 3, 5);  return 0; }**

3.二级指针的传参

当函数的参数为二级指针的时候，可以接收什么参数?

test(二级指针变量);

test(一级指针变量的地址);

int arr[10];test(arr) ;*

#includevoid 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; }

六、函数指针

（1）.函数指针的写法

pf()这是函数，所以要先和 * 结合成为一个指针(*pf)外面再加一个()意思是这个指针指向的是一个函数，而指向这个函数的参数是int，所以就写成了(*pf)(int,int),指向这个函数的返回类型是int，所以最终为int(*pf)(int,int)

（2）.调用及代码示例

#includeint Add(int x, int y) {  return x + y; } int main() {  printf("%p\n", &Add);//&函数名得到的就是函数的地址  printf("%p\n", Add);  //函数的地址要存起来，就得放在【函数指针变量】中  int (*pf)(int, int) = Add;//函数名表示函数地址  //pf是函数指针的变量名  int ret = (*pf)(3, 5);//这种形式是对的  //int ret = Add(3, 5);  int ret = pf(3, 5);//这种形式是对的  printf("%d\n", ret);  return 0; }

根据上述代码可以知道&Add和Add地址一样的和数组是不同的；

（3）.示例

1．将0强制类型转换为void ( * )()类型的函数指针

2．这就意味着0地址处放着一个函数，函数没参数，返回类型是void

3．调用0地址处的这个函数

int main() {  (*( void (*)())0 )();  //void (*)())是一个函数指针类型类似上个代码int (*pf)(int, int)去掉函数指针变量名和函数参数  //在函数指针类型外面加上()是强制类型转换(void (*)()0)意思是将0强制类型转换  //加上*意思是对强制类型转换后的解引用  //最后的()调用时候传参 }

（4）.示例

上述的代码是一个函数的声明

函数的名字是signal

signal函数的参数第一个是int类型，第二个是void()(int)类型的函数指针,该函数指针指向的函数参数是int，返回类型是void

signal函数的返回类型也是一个函数指针

该函数指针指向的函数参数是int，返回类型是void*

#includeint main() { void (* signal(int, void(*)(int) ) )(int); //把这个去掉signal(int, void(*)(int) ) //就变成了void (* )(int);所以说signal的返回类型也是一个函数指针 return 0 }

七、函数指针数组

（1）.代码示例

数组的每个元素是一个函数指针

#includeint 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 (*pf[4])(int, int) = { Add,Sub,Mul,Div };  //pf[4]先和[]结合变成一个数组，数组元素是4个，去掉pf[4]后int (*)(int, int)这是一个函数指针类型  int i = 0;  for (i = 0; i < 4; i++)  {  int ret = pf[i](8, 4);//pf[i]；i为0的时候拿到Add依次往后拿到的是Sub,Mul,Div,然后调用传参。  printf("%d\n", ret);  }  return 0; }

（2）.用函数数组写一个计算器

当不用函数指针数组写的时候：

#includeint 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; } void menu() {  printf("************************\n");  printf("** 1.add ** 2.sub **\n");  printf("** 3.mul ** 4.div **\n");  printf("****0.exit**************\n");  printf("************************\n"); } int main() {  int input = 0;  int x = 0;  int y = 0;  int ret = 0;  do  {  menu();  printf("请选择:>");  scanf("%d", &input);  switch (input)  {  case 1:  printf("请输入两个操作数:>");  scanf("%d %d", &x, &y);  ret = Add(x, y);  break;  case 2:  printf("请输入两个操作数:>");  scanf("%d %d", &x, &y);  ret = Sub(x, y);  break;  case 3:  printf("请输入两个操作数:>");  scanf("%d %d", &x, &y);  ret = Mul(x, y);  break;  case 4:  printf("请输入两个操作数:>");  scanf("%d %d", &x, &y);  ret = Div(x, y);  break;  case 0:  printf("退出程序\n");  break;  default:  printf("选择错误\n");  break;  }  printf("%d\n", ret);  } while (input);  return 0; }

当用函数指针数组写的时候：

相较于第一种它更简洁

#includeint 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; } void menu() {  printf("************************\n");  printf("** 1.add ** 2.sub **\n");  printf("** 3.mul ** 4.div **\n");  printf("****0.exit**************\n");  printf("************************\n"); } int main() {  int input = 0;  int x = 0;  int y = 0;  int ret = 0;  //转移表  int (*pfArr[5])(int, int) = { NULL,Add,Sub,Mul,Div };  do  {  menu();  printf("请选择:>");  scanf("%d", &input);  if (input >= 1 && input <= 4)  {  printf("请输入两个操作数:>");  scanf("%d %d", &x, &y);  ret = pfArr[input](x, y);  printf("%d\n", ret);  }  else if (input == 0)  {  printf("退出程序\n");  break;  }  else  {  printf("选择错误\n");  }  } while (input);  return 0; }

总结

以上就是对C-指针的进阶中的一部分的简单了解