目录
指针介绍：
- 指针就是个变量，用来存放地址，地址唯一标识一块内存空间。
- 指针的大小是固定的4/8个字节(32位平台/64位平台)。
- 指针是有类型，指针的类型决定了指针的 + -整数的步长，指针解引用操作的时候的权限。
一、字符指针
字符指针是C语言中用于存储字符串地址的指针类型。在C语言中，字符串实际上是以空字符（'\0'）结尾的字符数组。字符指针通过存储这个字符数组的首地址来引用整个字符串。
1.字符指针指向一个字符
int main()
{
char ch = 'q';
char* pc = &ch; //pc就是一个char*类型的指针变量
//* - 说明pc是一个指针变量
return 0;
}2.字符指针指向一个字符串
int main()
{
char* ps = "hello word"; //把字符串的首字符的地址放在指针中：h的地址放在ps中
printf("%c\n", *ps); //h
return 0;
}3.例题
判断下面是否相等：
（1）对于数组名（如 strl 和 str2）的比较：
在C语言中，数组名在大多数情况下被当作指向数组首元素的指针。但是，当数组名出现在表达式中时（除了少数例外，如 sizeof 运算符或 & 运算符作用于数组名），它们会被转换为指向数组首元素的指针。然而，这并不意味着两个不同数组名（即使它们的内容相同）的比较会返回真（即它们指向同一个地址）。实际上，每个数组（即使它们的内容相同）都存储在内存的不同位置，因此它们的地址是不同的。
（2）对于字符串字面量（如 "hello word."）的比较
当声明 char* str3 = "hello word."; 和 char* str4 = "hello word."; 时，str3 和 str4 都被初始化为指向这个字符串字面量的指针，str3中放的是h的地址，str4中也放的是h的地址，因此他俩放在用一个地址里面。
int main()
{
char strl[] = "hello word."; //str1和str2是两个地址
char str2[] = "hello word.";
char* str3 = "hello word."; //str3中放的是h的地址
char* str4 = "hello word."; //str4中也放的是h的地址，因此他俩放在用一个地址里面
if (strl == str2)
printf("strl and str2 are same\n");
else
printf("strl 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;
}二、指针数组
指针数组是一个数组，其元素是指针
1.基本定义
（1）指针数组的定义方式如下：
int *ptrArray[10]; // 定义一个包含10个int类型指针的数组在这个例子中，ptrArray 是一个数组，它包含 10 个元素，每个元素都是一个指向 int 类型的指针。这意呀着你可以使用这个数组来存储 10 个 int 变量的地址。
（2）下面是一个使用指针数组的示例，该示例创建了一个整数数组，并使用指针数组来存储这些整数的地址：
#include <stdio.h>
int main() {
int numbers[5] = {1, 2, 3, 4, 5}; // 定义一个整数数组
int *ptrArray[5]; // 定义一个包含5个int指针的数组
// 将整数数组的每个元素的地址赋给指针数组
for (int i = 0; i < 5; i++) {
ptrArray[i] = &numbers[i];
}
// 通过指针数组访问并打印整数数组的值
for (int i = 0; i < 5; i++) {
printf("%d ", *ptrArray[i]); // 解引用指针数组的元素以访问对应的整数值
}
return 0;
}在这个示例中，我们首先定义了一个整数数组 numbers，然后定义了一个指针数组 ptrArray。我们使用一个循环将 numbers 数组中每个元素的地址存储在 ptrArray 中。然后，我们使用另一个循环通过 ptrArray 中的指针来访问和打印 numbers 数组中的值。
2.arr和&arr的区别
arr在表达式中通常被当作指向数组首元素的指针。&arr获取的是整个数组的地址，并且其类型是指向数组的指针，包含了数组的大小信息（在类型中隐含）。
根据下面的代码我们发现，其实&arr和arr，虽然值是一样的，但是意义是该不一样的。
int main()
{
int arr[10] = { 0 };
int* p1 = arr;
int (*p2)[10] = &arr;
printf("%p\n", arr);
printf("%p\n", &arr); //打印出来结果相同,但是意义不同
printf("\n%p\n", p1); //p1是一个整型指针
printf("%p\n", p1 + 1); //p1+1：跳过四个字节
printf("\n%p\n", p2); //p2是一个数组指针
printf("%p\n", p2 + 1); //p2+1：跳过一个数组
return 0;
}三、数组指针
数组指针是指向数组的指针。更具体地说，它是一个指针，指向一个数组的第一个元素.
int arr[10]; // 定义一个包含10个int的数组
int (*p)[10] = &arr; // p是一个指向包含10个int的数组的指针1.数组指针的例子
int main()
{
//(1)整形指针
int a = 10;
int* pa = &a;
//(2)字符指针
char ch = 'w';
char* pc = &ch;
//(3)数组指针
int arr[10] = { 1, 2, 3, 4, 5 };
arr; //arr - 数组名是首元素的地址 - arr[0]的地址
int (*parr)[10] = &arr; //parr就是一个数组指针 - 其中存放的就是数组的地址
double* d[5];
double* (*pd)[5] = &d;
return 0;
}2.数组指针的使用
(1)第1种使用
int main()
{
int arr[10] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
int (*pa)[10] = &arr;
int i = 0;
for (i = 0; i < 10; i++)
{
printf("%d ", *((*pa) + i));
//(*pa）就是对数组指针解引用，相当于拿到数组arr，也就是第一个元素的位置
}
return 0;
}(2)第2种使用
print2 函数展示了如何使用一个指向数组的指针（在这个例子中是指向一个包含5个整数的数组的指针）来遍历一个二维数组。这个函数接收一个指向 int[5] 类型的指针 p，以及两个整数 r 和 c，分别代表二维数组的行数和列数。
void print1(int arr[3][5], int r, int c)
{
int i = 0;
int j = 0;
for (i = 0; i < r; i++)
{
for (j = 0; j < c; j++)
{
printf("%d ", arr[i][j]);
}
printf("\n");
}
}
void print2(int (*p)[5], int r, int c) //p是一个数组指针
{
int i = 0;
int j = 0;
for (i = 0; i < r; i++)
{
for (j = 0; j < c; j++)
{
printf("%d ", *(*(p+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);
print2(arr, 3, 5); //arr数组名，表示数组首元素的地址
//二维数组的数组名表示首元素的地址
//二维数组的首元素是:第一行!
return 0;
}四、数组传参和指针传参
1.一维数组传参
（1）一维数组传参：可以写成一维数组，数组大小可以省略，也可以写成指针。
void test(int arr[10]) //写成一维数组
{}
void test(int arr[]) //数组大小可以省略
{}
void test(int *arr) //也可以写成指针
{}
int main()
{
int arr[10] = { 0 };
test(arr);
return 0;
}(2)如果一维数组是指针数组：可以写成指针数组，也可以写成
void test(int *arr[20]) //可以写成指针数组
{}
void test(int **arr) //也可以写成指针
{}
int main()
{
int *arr2[20] = { 0 };
test2(arr2);
return 0;
}2.二维数组传参
二维数组传参，入[]的数字。函数形参的设计只能省略第一个[]的数字
因为对一个二维数组，可以不知道有多少行，但是必须知道一行多少元素，这样才方便运算。
void test(int arr[3][5]) //二维数组
{}
void test(int arr[][]) //这样是不行的，列不能省略
{}
void test(int arr[][5]) //可以
{}
void test(int *arr) //不可以
{}
void test(int* arr[5]) //不行
{}
void test(int (*arr)[5]) //可以
{}
void test(int **arr) //不可以
{}
int main()
{
int arr[3][5] = { 0 };
test(arr);
}3.一级指针传参
一级指针传参，一级指针接收。
一个一级指针传参的例子如下：
void print(int* ptr, int sz)
{
int i = 0;
for (i = 0; i < sz; i++)
{
printf("%d \n", *(ptr + i));
}
}
int main()
{
int arr[10] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
int* p = arr;
int sz = sizeof(arr) / sizeof(arr[0]);
print(p, sz); //p是一个一级指针，这里进行一级指针传参
}4.二级指针传参
一个二级指针传参的例子如下：
void test(int** p2)
{
**p2 = 20;
}
int main()
{
int a = 10;
int* pa = &a; //pa是一级指针
int** ppa = &pa; //ppa是二级指针
//二级指针进行传参
test(ppa);
printf("%d\n", a);
return 0;
}五、函数指针
函数指针的定义方式与普通指针类似，但是指向的是一个函数而非变量。其基本格式如下：
返回类型 (*指针名)(参数类型列表);1.几种基本指针类型对比
int Add(int x, int y)
{
return x + y;
}
int main()
{
//整形指针
int a = 10;
int* pa = &a;
//字符指针
char ch = 'w';
char* pc = &ch;
//数组指针
int arr[10] = { 0 };
int (*parr)[10] = &arr; //取出数组的指针
//parr是指向数组的指针 - 存放的是数组的地址
//函数指针 - 存放函数地址的指针
//&函数名 - 取到的就是函数的地址
int (*pf)(int, int) = &Add; //pf就是一个函数指针
printf("%p\n", &Add); //注： 数组名 != &数组名
printf("%p\n", Add); //但是 - 函数名 == &数组名
return 0;
}2.函数指针基本结构
一个示例：
void test(char* str)
{
}
int main()
{
void (*pt)(char*) = &test;
return 0;
}3.指针函数的调用
int Add(int x, int y)
{
return x + y;
}
int main()
{
//第1种写法：
int (*pf)(int, int) = &Add; //pf1就是一个函数指针
int ret1 = (*pf)(3, 5); //第1种 - 函数指针的调用
printf("ret1=%d\n", ret1);
//第2种写法：
int (*pf)(int, int) = Add; //可行 - Add 等价于 pf
int ret2 = Add(3, 5); //第2种 - 函数指针的调用
printf("ret2=%d\n", ret2);
//第3种写法：
int (*pf)(int, int) = Add;
int ret3 = pf(3, 5); //第3种 - 函数指针的调用
printf("ret3=%d\n", ret3);
return 0;
}六、函数指针数组
函数指针数组是一种特殊的数组，其元素是指向函数的指针。这种数组允许你存储多个函数的地址，并能够通过数组索引来调用这些函数。
1.函数指针数组基本结构
int Add(int x, int y)
{
return x + y;
}
int Sub(int x, int y)
{
return x - y;
}
int main()
{
int (*pf1)(int, int) = Add;
int (*pf2)(int, int) = Sub;
int(*pfArr[2])(int, int) = {Add, Sub}; //pfArr就是函数指针数组
return 0;
}2.函数指针数组应用
一个例子：计算器 - 计算整形变量的加、减、乘、除
（1）下面为笨方法实现
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;
}
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;
//计算器 - 计算整形变量的加、减、乘、除
do
{
menu();
int x = 0;
int y = 0;
int ret = 0;
printf("请选择：");
scanf("%d", &input);
switch (input)
{
case 1:
printf("请输入两2个操作数：");
scanf("%d %d", &x, &y);
ret = Add(x, y);
printf("ret = %d\n", ret);
break;
case 2:
printf("请输入两2个操作数：");
scanf("%d %d", &x, &y);
ret = Sub(x, y);
printf("ret = %d\n", ret);
break;
case 3:
printf("请输入两2个操作数：");
scanf("%d %d", &x, &y);
ret = Mul(x, y);
printf("ret = %d\n", ret);
break;
case 4:
printf("请输入两2个操作数：");
scanf("%d %d", &x, &y);
ret = Div(x, y);
printf("ret = %d\n", ret);
break;
case 0:
printf("退出程序！！！\n");
break;
default:
printf("选择错误，请重新选择！！！\n");
break;
}
} while (input);
return 0;
}（2）使用函数指针数组，来简化代码
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;
}
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;
计算器 - 计算整形变量的加、减、乘、除
还想实现：a&b、a^b、a|b、...
do
{
menu();
函数指针数组起到转移表的作用
int(*pfArr[5])(int, int) = {NULL, Add, Sub, Mul, Div }; //函数指针数组
int x = 0;
int y = 0;
int ret = 0;
printf("请选择：");
scanf("%d", &input);
if (input >= 1 && input <= 4)
{
printf("请输入两2个操作数：");
scanf("%d %d", &x, &y);
ret = (pfArr[input])(x, y); //通过下标访问不同的元素，不同的元素中放的是不同的函数的地址
printf("ret = %d\n", ret);
}
else if (input == 0)
{
printf("退出程序\n");
break;
}
else
{
printf("选择错误，请重新选择！！！\n");
}
} while (input);
return 0;
}七、指向函数指针数组的指针
概念：指向函数指针数组的指针是一个 指针 指针指向一个 数组，数组的元素都是 函数指针;
1.几种数组对比
int main()
{
int arr[5]; //整形数组
int (*p1)[5] = &arr; //取出的是整形数组的地址
int* arr[5]; //整形指针数组
int* (*p2)[5] = &arr; //取出的是整形指针数组的地址
//p2是指向【整形指针数组】的指针
int(*p)(int, int); //函数指针
int(* p2[4])(int, int); //函数指针数组
int(* (*p3)[4]) = &p2; //取出的是函数指针数组的地址
//p2是指向【函数指针数组】的指针
}2.指向函数指针数组的指针基本结构
void test(const char* str)
{
printf("%s\n", str);
}
int main()
{
//函数指针
void (*pfun)(const char*) = test;
//函数指针的数组pfunArr
void(*pfunArr[5])(const char);
pfunArr[0] = test;
//指向函数指针数组pfunArr的指针
void (*(*ppfunArr)[10])(const char*)= &pfunArr;
return 0;
}
扫一扫
2654
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
