1.字符指针变量
//int main()
//{
// char ch = 'w';
// char*pc=&ch;
// printf("%c", *pc);
// return 0;
//}
/*int main()
{
//char* p = "abcdef";
//char arr[] = "abcdef";//常量字符串 a b c d e f \0
//char* pc = arr;//将数组首元素的地址存在p中
const char* p = "abcdef";//这里的赋值是讲字符串中首字符的地址存在p中
printf("%c\n", *p);//打印a
//如何打印一整个字符串呢？
printf("%s\n", p);//使用%s打印字符串的时候，只需要提供首字符的地址就行了
//*p='q'------不允许修改，因为p指向的是常量字符串，常量字符串不能被修改
//在5303行添加const可以防止*p被修改
return 0;
}*/
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");
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 and str2 are not same
str3 and str4 are same
为什么会出现这种情况呢？
str1是一个数组
str2是一个数组，只是内容相同而已
"hello bit."是一组常量字符串，是不能被修改的
内容相同的常量字符串只需要保存一份就可以
str3和str4存的都是h的地址，两个指针变量各自指向同一个地址
在这个条件语句中if (str1 == str2)
str1是数组名，首元素的地址，str2也是数组名，也是首元素的地址
str1和str2各占两份不同的空间，只是内容一样
完全不同的两个空间
在这个条件语句中if (str3 == str4)
str3和str4存放的都是h的地址，存放的是同一个地址
所以二者相同
这个代码里面的比较，不是比较字符串，比较的是地址
*/
使用%s打印字符串的时候，只需要提供首字符的地址就行了
char* p = "abcdef";//这里的赋值是讲字符串中首字符的地址存在p中
2.数组指针变量
指针数组--是数组--存放的是指针（地址）
数组指针是什么呢？
类比：字符指针--char*---指向字符的指针--字符指针变量中存放字符的地址
char ch='w';
char *pc=&ch;
整型指针---int*--指向整型的指针--整型指针变量中存放的整型变量的地址
int a=10
int *p=&a
那么数组指针就是指向数组的指针
数组指针变量存放的是数组的地址
数组的地址--&数组名
指针数组
1.是数组
2.是存放指针的数组
char* arr[6]-----char*是数组的元素类型---存放字符串指针的数组
int *arr2[5]---存放整型指针的数组
数组指针
是指针，指向数组的指针
*p--表示这是一个指针变量
这个指针指向的是数组，得有大小[10]
(*p)[10]
数组指向的元素类型是什么呢？在前面加上类型
int (*p)[10]--这里的p就是数组指针，P指向的数组有10个元素，每个元素的类型是int
p的类型是int (*)[10]
将数组的地址取出来，存放在指针变量里面，
char（ptr）=&arr---arr里面都是char类型的
//指针数组
//int main()
//{
// int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
// int(*p)[10] = &arr;//取出的是数组的地址，那么数组的地址就应该放到数组指针里面
//
// //想使用p这个数组指针访问arr数组的内容
// //p里面放的是数组的地址，那么*p就相当于拿到了一个数组
// for (int i = 0; i < 10; i++)
// {//*p就是数组，那么咱们加上[i]就说明直接访问arr[i],随着i的变化，逐步打印数组内的内容
// printf("%d", (*p)[i]);
// }
// return 0;
//}
//上面这种就显得有点麻烦
//int main()
//{
// //int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
// //int(*p)[10] = &arr;//取出的是数组的地址，那么数组的地址就应该放到数组指针里面
//
// 想使用p这个数组指针访问arr数组的内容
// p里面放的是数组的地址，那么*p就相当于拿到了一个数组
// //for (int i = 0; i < 10; i++)
// //{//*p就是数组，那么咱们加上[i]就说明直接访问arr[i],随着i的变化，逐步打印数组内的内容
// // printf("%d", (*p)[i]);
// //}
// int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
// int* p = arr;
// for (int i = 0; i < 10; i++)
// {
// printf("%d",p[i]);//p就是首元素的地址 p[i]---*(p+i)
// }
//
//
// return 0;
//}
3.二维数组传参的本质
不管是一位数组还是二维数组传参，形参可以写成数组，也可以写成指针
这里要对数组名做一个深入的理解
咱们要考虑到arr是数组首元素的地址
数组名+i就是跳过i个数组
arr[i]-----(arr+i)---第i行 arr[i][j]-----((arr+i)+j)---(arr+i)是第i行首元素的地址，+j就表示下标为j的数字的地址，再解引用就能得到下标为j的数字
对于一个二维数组的话，arr是数组名，同时也是这个二维数组第一行的元素地址
arr+i就是这个二维数组第i行的地址
对于(*(arr + i))[j]的理解
*(arr + i)就是这个二维数组的第i行的地址解引用得到第i行
[j]这个就是第i行下标为j的元素
对于((arr + i)+j)的理解
*(arr + i)是第i行首元素的地址，这个首元素的地址+j就是第i行下标为j的数字的地址，
*(arr + i)+j再将其解引用得到的就是第i行下标为j的元素
//二维数组传参的本质
/*void print(int arr[3][5], int r, int c)
{
//两层循环，第一层循环打印行，第二层循环打印列
for (int i = 0; i < r; i++)
{
for (int 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);//将arr数组的内容打印出来,数组名、行和列都要传上去
return 0;
}*/
//一维数组传参
/*数组名是首元素的地址
* 一维数组在传参的时候，其实传递的是首元素的地址
*
* 函数的参数可以写成数组，也可以写成指针
*
* 那么二维数组呢？
* 二维数组的数组名该如何理解呢？
* 其实二维数组的数组名也是数组首元素的地址，但是是那个数字呢？
二维数组可以理解为一维数组的数组
将二维数组里面的三个一维数组当成一个元素
二维数组有三个元素，每个元素有三个数组
二维数组的每一行可以看成是一个一维数组‘二维数组的首元素就是这个二维数组的第一行
二维数组的数组名就是第一行的地址
不是第一行首元素的地址，而是第一行整个一维数组的地址
*/
void print(int(*arr)[5], int r, int c)//因为传过来的是一位数组的地址，我们要用数组指针接收
//使用数组指针存放第一行的地址，传过来的是一个一维数组，那么我们就需要一个数组指针来接收
{//这个数组指针并不是指向的二维数组，而是指向的是这个二维数组的第一行
//两层循环，第一层循环打印行，第二层循环打印列
for (int i = 0; i < r; i++)
{
for (int j = 0; j < 5; j++)
{
//第一行是arr
//第二行是arr+1
printf("%d ", (*(arr + i))[j]);//arr+i就是第几行，*(arr + i)就是解引用相当于直接访问数组后面的[j]就是那一行一维数组里面的第几个元素
} //printf("%d ", *(*(arr + i)+j))
//arr+i是某一行的地址，将其括起来解引用就是这一行,相当得到第i行的数组名
// *(arr+i)==arr[i]，arr[i]是第i行的数组名，数组名是数组首元素的地址
// *(arr + i)数组首元素的地址+j就是这一行首元素后面第j个元素的地址，再解引用
// 再将这个地址解引用得到的就是数组首元素
// *(arr + i)一行首元素的地址再+j就是下标为j的元素了
// 对于这个二维数组，arr[i]表示的是arr[i][0]，第i行第1个元素的地址
//
//
//*(arr + i)这个是某一行，相当于拿到这一行的数组名字
//对于二维数组arr的话
//arr[0]是第一行的数组名
//arr[1]是第二行的数组名
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);//将arr数组的内容打印出来,数组名、行和列都要传上去
//arr是在这个二维数组首元素的地址，是第一行的地址，第一行是一位数组
//这里传过去的是第一行的地址
return 0;
}
/*不管怎么写对于二维数组arr+i就是这个二维数组的第i行一维数组，
* 传参时的arr是二维数组第一行，
*
* 数组名+i就是跳过一整个数组，对于二维数组，里面是存在好几个一维数组的
对于(*(arr + i))[j]的理解
*(arr + i)就是这个二维数组的第i行的地址解引用得到第i行
[j]这个就是第i行下标为j的元素
对于*(*(arr + i)+j)的理解
*(arr + i)是第i行首元素的地址，这个首元素的地址+j就是第i行下标为j的数字的地址，
*(arr + i)+j再将其解引用得到的就是第i行下标为j的元素
arr[i]-----*(arr+i)---第i行
arr[i][j]-----*(*(arr+i)+j)---*(arr+i)是第i行首元素的地址，+j就表示下标为j的数字的地址，再解引用就能得到下标为j的数字
*/
*(*(arr+i)+j) 是访问二维数组中第i行，第j列元素的方法。
在C语言中，二维数组可以看作是由多个一维数组组成的连续存储空间。定义一个 int 类型的二维数组 arr，用 arr[i][j] 表示其第 i 行、第 j 列的元素，也可以写成 *(*(arr+i)+j)。
解释 *(*(arr+i)+j) 的过程如下：
-
arr是一个指向二维数组首地址的指针，*(arr+i)表示访问第i个一维数组的首地址。 -
*(arr+i)+j表示在第i个一维数组的基础上向后移动j个位置，即访问第i行、第j列元素的地址。 -
*(*(arr+i)+j)表示访问上述地址所存储的值，即获取第i行、第j列的元素值。
(*(arr + i))[j] 也可以用来访问二维数组中第 i 行，第 j 列的元素。
在C语言中，二维数组可以看作是由多个一维数组组成的连续存储空间。定义一个 int 类型的二维数组 arr，用 arr[i][j] 表示其第 i 行、第 j 列的元素，也可以写成 *(*(arr+i)+j) 或 (*(arr + i))[j]。
解释 (*(arr + i))[j] 的过程如下：
-
arr是一个指向二维数组首地址的指针，*(arr + i)表示访问第i个一维数组的首地址。 -
(*(arr + i))[j]表示使用[]运算符访问该一维数组中下标为j的元素，即获取第i行、第j列的元素值。
4.函数指针变量
变量有地址，数组有地址，函数是否有地址呢？
/*int Add(int x, int y)
{
return x + y;
}
int main()
{
printf("%p\n", &Add);//地址是00701040
printf("%p\n", Add);//地址是00701040
//这两种写法没区别
//如果想将函数名存起来怎么搞呢？
int(*pf)(int,int) = &Add;//函数指针变量
//*和pf结合，表示pf是指针变量
//后面的（int,int）是指向的那个函数的参数
//前面的int是指向的那个函数的返回类型
//那么pf的指针类型是什么呢？
//int(*)(int,int)---pf的类型
//交代pf指向的函数的参数个数和类型就行
//那我们能通过这个pf调用这个函数呢？
int ret=(*pf)(4, 5);//pf是地址，加*解引用，然后得到函数后咱们就要提供数据，传参，在后面的括号内添加数据
printf("%d", ret);//打印的结果就是9
//int ret =Add(4,5)
//还存在一种写法：int ret=pf(4, 5);---直接用过pf找到函数，因为pf里面存放的是函数的地址
//只要是函数指针变量就能这么写，可以不写*
//如果要写*的话，那么就要带上括号
//通过函数的地址，也能调用函数
return 0;
}*/
//对于这种复杂的代码，我们应该如何简单化呢？
return 0;
}*/
/*typedef unsigned int unit;//将unsigned int类型的数重定义名字为unit
int main()
{
unsigned int num;//把一个相对长的类型简单化了
unit num2;
//上面两个代码的内容是一样的
return 0;
}*/
//typedef是用于类型重命名的，可以将复杂的类型简单化
//但如果是指针，能否重命名呢？
//typedef int* pint_t;
//int main()
//{
// pint_t p2;//整形指针
//
//
//
// return 0;
//}
//那么对于复杂点的数组指针和函数指针该如何命名呢？
/*typedef int(*parr_t)[6];
//对于数组指针重命名时，新的名字应该放在*的旁边
int main()
{
int arr[6] = { 0 };
int(*p)[6]= & arr;//当我们把名字去掉，那么剩下的就是p的类型了
//p是指针变量的的名字
//在重新定义的时候，新的名字放在原本p的位置
parr_t p2;
return 0;
}*/
//现在对函数重命名
/*typedef int(*pf_t)(int, int);//函数的重命名还是把新名字放到*号旁边
Add(int x, int y)
{
return x + y;
}
int main()
{
int(*pf)(int ,int)=Add;//去掉名字就是函数指针类型
pf_t pf2 = Add;
return 0;
}*/
整型指针、数组指针、函数指针
5.函数指针数组
int Add(int x, int y)
{
return x + y;
}
int Sub(int x, int y)
{
return x - y;
}
int Mull(int x, int y)
{
return x * y;
}
int Div(int x, int y)
{
return x / y;
}
//指针数组
int main()
{
//int* arr1[6];整型指针数组
//char* arr2[5];字符指针数组
//arr[3][5];//每个元素是函数---函数指针数组
int (*pf1) (int ,int) = Add;
int (*pf2) (int, int) = Sub;
int (*pf3) (int, int) = Mull;
int (*pf4) (int, int) = Div;
//函数指针数组来存放这些函数的地址呢？
//函数指针数组从函数指针的基础来写
int (*pf[4]) (int, int) = { Add, Sub ,Div ,Mull };//将函数指针放到函数指针数组里面
//通过下标来找数据
for (int i = 0; i < 4; i++)
{
int ret=pf[i](6,2);//后面的括号内放的是计算的数据
printf("%d\n", ret);
}
return 0;
}
从函数指针的基础来写函数指针数组来写是最方便的
存放的都是相同类型的元素
6.转移表
函数指针数组
创建函数指针数组来调用
//实现一个计数器
//完成加减乘除
/*int Add(int x, int y)//加法
{
return x + y;
}
int Sub(int x, int y)//减法
{
return x - y;
}
int Mull(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. mull 4. div *************\n");
printf("************** 0. exit *************\n");
}
int main()
{
int input = 0;
int x =0, y = 0,ret=0;
do
{
menu();//菜单
printf("请选择");
scanf("%d", &input);
switch (input)//判断输入的值
{
case 1:
printf("请输入两个操作数");
scanf("%d %d", &x, &y);//输入数字
//调用函数Add
ret=Add(x, y);
printf("%d\n", ret);
break;
case 2:
printf("请输入两个操作数");
scanf("%d %d", &x, &y);//输入数字
//调用函数Sub
ret = Sub(x, y);
printf("%d\n", ret);
break;
case 3:
printf("请输入两个操作数");
scanf("%d %d", &x, &y);//输入数字
//调用函数Mull
ret = Mull(x, y);
printf("%d\n", ret);
break;
case 4:
printf("请输入两个操作数");
scanf("%d %d", &x, &y);//输入数字
//调用函数Div
ret = Div(x, y);
printf("%d\n", ret);
break;
case 0:
printf("退出计算器\n");
break;
default://输入的值不是这里面的任何的一个值
printf("选错了，重新选择\n");
break;
}
} while (input);
return 0;
}*/
//这种写法过去复杂，对于不同符号的计算
//
//将这些函数的地址放到 一个指针数组里面
int Add(int x, int y)//加法
{
return x + y;
}
int Sub(int x, int y)//减法
{
return x - y;
}
int Mull(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. Mull 4. div *************\n");
printf("************** 0. exit *************\n");
}
int main()
{
int input = 0;
int x =0, y = 0,ret=0;
//创建一个数组放函数
//函数指针数组---转移表
int (*pfArr[5])(int, int) = {0, Add,Sub,Mull,Div};
// 0 1 2 3 4 下标
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");
}
else//选择的不是这些值
{
printf("选择错误，重新选择\n");
}
} while (input);
return 0;
}
//通过数组的方式把函数都调用起来，用过下标找到函数再进行调用