进阶指针
一、字符指针
例如下面代码,pc就是一个字符指针;"abcdef"是一个常量字符串,不能被修改,pb里面存的是该常量字符串的首字符’ a '的地址。
int main()
{
char ch = 'w';
char *pc = &ch;
char *pb = "abcdef";
*pc = 'w';
return 0;
}
二、指针数组
首先,先来回忆一下数组的类型:
字符数组----存放字符的数组char arr[5];
整型数组----存放整型的数组int arr[5];
所以,可以理解指针数组就是存放指针的数组;
存放字符指针的数组----字符指针数组char* arr[5];
存放整型指针的数组----整型指针数组int* arr[5];
例如,下面代码int* arr[]是个整型指针数组;
int main()
{
int a = 10;
int b = 20;
int c = 30;
int d = 40;
int* arr[] = { &a,&b,&c,&d };
int i = 0;
for (i = 0; i < 4; i++)
{
printf("%d ", *(arr[i]));
}
return 0;
}
三、数组指针
1.定义
整形指针 - 指向整型的指针
int a = 10;
int* p = &a;
字符指针 - 指向字符的指针
char ch = ' w ';
char* pc = &ch;
数组指针 - 指向数组的指针;&arr取出的是整个数组的地址,pa首先和 * 结合是指针,这个指针指向大小为10的数组,数组中元素的类型是int.
[ ]的优先级要高于 * 号的,所以必须加上()来保证p先和*结合。
int arr[10];
int (*pa)[10] = &arr;
2. &arr和arr
数组名绝大部分情况下是数组首元素的地址
但是有2个例外:
(1) sizeof(数组名) - sizeof内部单独放一个数组名的时候,数组名表示的整个数组,计算得到的是数组的总大小
(2) &arr - 这里的数组名表示整个数组,取出的是整个数组的地址,从地址值的角度来讲和数组首元素的地址是一样的,但是意义不一样
任何时候看到数组名都要先判断是不是上面两种例外,因为这会影响指针走的步长;例如下面代码:arr + 1和&arr[0] + 1都是向后跳过4个字节,它们的类型都是int*.
而&arr 的类型是: int(*)[10] ,是一种数组指针类型;数组的地址+1,跳过整个数组的大小,所以 &arr+1 相对于 &arr 的差值是40
int main()
{
int arr[10] = { 0 };
printf("%p\n", arr); //int *
printf("%p\n", arr+1); //4
printf("%p\n", &arr[0]); //int*
printf("%p\n", &arr[0]+1); //4
printf("%p\n", &arr); //int(*)[10]
printf("%p\n", &arr+1); //40
int (*p)[10] = &arr; //p是一个数组指针
//int(*)[10]
return 0;
}
3. 数组指针的应用
参数是数组的形式
void print1(int arr[3][5],int x ,int y)
{
int i = 0;
int j = 0;
for (i = 0; i < x; i++)
{
for (j = 0; j < y; j++)
{
printf("%d ", arr[i][j]);
}
printf("\n");
}
}
参数是指针的形式
以下四种等价:
printf("%d ", p[ i ][ j ]);
printf("%d ", * ( p[ i ] + j)); //p[i]是第i行首元素的地址,加上j跳过一个整型,即找到下一个元素的地址,解引用就是下一个元素
printf("%d ", * (* (p + i)+ j )); //*(p + i)找到这一行的地址
printf("%d ", ( * (p + i ))[ j ]);
void print2(int(*p)[5], int x, int y)
{
int i = 0;
for (i = 0; i < x; i++)
{
int j = 0;
for (j = 0; j < y; j++)
{
//以下四种等价
//printf("%d ", p[i][j]);
//printf("%d ", *(p[i] + j));
//printf("%d ", *(*(p + i)+j)); //*(p + i)找到这一行的地址
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);
printf("\n");
print2(arr, 3, 5);
return 0;
}
注意:数组名arr,表示首元素的地址,但是二维数组的首元素是二维数组的第一行,所以这里传递的arr,其实相当于第一行的地址,是一维数组的地址,可以用数组指针来接收;这里二维数组的初始化要用两个{}初始化.
解读代码:
int arr[5]; arr是一个5个元素的整型数组
int* parr1[10]; parr1是一个数组,数组有10个元素,每个元素的类型是int,parr1是指针数组
int(*parr2)[10]; parr2是一个指针,该指针指向了一个数组,数组有10个元素,每个元素的类型都是int,parr2是数组指针
int(*parr3[10])[5];([]的优先级比*高,所以parr3先和[]结合成数组)parr3是一个数组,该数组有10个元素,每个元素是一个数组指针,该数组指针指向的数组有5个元素,每个元素是int
四、数组传参和指针传参
1. 数组传参
(1)一维数组传参(以下都可以)
void test(int arr[])
{}
void test(int arr[10])
{}
void test(int* arr)
{}
void test2(int *arr[20])
{}
void test2(int **arr)
{}
int main()
{
int arr[10] = { 0 };
int arr2[20] = { 0 };
test(arr);
test2(arr2);
return 0;
}
(2)二维数组传参(以下都可以)
二维数组传参,如果用指针接收,传过去的是第一行的地址,形参就应该是数组指针.
void test(int arr[3][5])
{}
void test1(int arr[][5])
{}
void test2(int (*arr)[5])
{}
int main()
{
int arr[3][5] = { 0 };
test(arr);//二维数组传参
test1(arr);
return 0;
}
2. 指针传参
二级指针传参(以下都可以)
void test(char ** p)
{}
//以下的都可以传上来
int main()
{
char c = 'b';
char* pc = &c;
char** ppc = &pc;
char* arr[10];
test(&pc);
test(ppc);
test(arr);
return 0;
}
五、函数指针
函数指针:指向函数的指针(存放函数地址的指针)
其中,函数名和&函数名都是函数的地址,没有区别.
(1)下面的int (*pa)(int, int)就是一个函数指针,pa先和 * 结合成一个指针,指针指向一个函数,函数类型都是int,返回类型是int;其中int( * )(int,int)是一个函数指针类型;
int Add(int x, int y)
{
return x + y;
}
int main()
{
int a = 10;
int b = 20;
printf("%p\n", &Add); //&函数名和函数名都是函数的地址
printf("%p\n", Add);
int (*pa)(int, int) = Add; //把Add函数的地址存到pa里面去(指针指向一个函数,函数类型是int,返回类型是int)
printf("%d\n", (*pa)(2, 3)); //调用函数
return 0;
}
(2)
void Print(char* str)
{
printf("%s\n", str);
}
int main()
{
void (*p)(char*) = Print; //把Print函数的地址存到p里
(*p)("hello world"); //调用函数
return 0;
}
(3)解读代码:
代码1:void(* signal(int, void(*)(int)))(int);
signal是一个函数声明;
signal函数的参数有两个,第一个是int,第二个是函数指针,该函数指针指向的函数参数类型是int,返回类型是void;;
signal函数的返回类型也是一个函数指针,该函数指针指向的函数的参数是int,返回类型是void;
代码2:(* ( void (*)() ) 0)();
这是一次函数调用;
将0强制类型转换为void (*)() 类型的函数指针;
这就意味着0地址处放着一个函数,函数没参数,返回类型是void;
调用0地址处的这个函数;
六、函数指针数组
1. 定义
把函数的地址存到一个数组中,那这个数组就叫函数指针数组,函数指针数组的定义:int (*parr1[10])( );首先parr1和[ ]结合成数组,数组的内容是int ( * )() 类型的函数指针.
2. 函数指针数组的应用 - 转移表
计算器
int add(int a, int b)
{
return a + b;
}
int sub(int a, int b)
{
return a - b;
}
int mul(int a, int b)
{
return a * b;
}
int div(int a, int b)
{
return a / b;
}
int main()
{
int x = 0;
int y = 0;
int (*p[5])(int x, int y) = { 0,add,sub,mul,div };
// 下标:0,1, 2, 3, 4
int input = 1;
while (input)
{
printf("*************************\n");
printf(" 1:add 2:sub \n");
printf(" 3:mul 4:div \n");
printf("****** 0:exit ********\n");
printf("请选择:");
scanf("%d", &input);
if (input == 0)
{
printf("退出计算器\n");
}
else if (input >= 1 && input <= 4)
{
printf("请输入两个数:\n");
scanf("%d %d", &x, &y);
int ret = p[input](x, y); //这里调用使用 (*p[input])(x, y)也可以
printf("%d\n", ret);
}
else
{
printf("输入有误,请重新输入\n");
}
}
return 0;
}
七、指向函数指针数组的指针
ppfArr 是一个数组指针,指针指向的数组有四个元素;
指向的数组每个元素的类型是一个函数指针 int(* )(int ,int);
int main()
{
int arr[10] = { 0 };
int(*p)[10] = &arr;
int (*pfArr[4])(int, int); //pfArr是一个数组--函数指针的数组
int (*(*ppfArr[4]))(int, int) = &pfArr; //ppfArr是一个指向函数指针数组的指针
return 0;
}
八、指针和数组的练习
数组和指针:
数组 - 能够存放一组相同类型的元素,数组的大小取决于数组的元素个数和元素类型
指针 - 地址/指针变量 ,大小是4/8个字节
数组是数组,指针是指针,二者不等价
数组名是数组首元素的地址,这个地址就可以存放在指针变量中
我们就可以使用指针来遍历数组
数组名
大部分情况下数组名是数组首元素的地址
但是有2个例外:
sizeof(数组名) - 数组名表示整个数组,计算的是整个数组的大小
&数组名 - 数组名表示整个数组,取出的是数组的地址
只要是看见数组名,首先判断是不是上面两个例外;
1. 一维数组
int a[] = {1,2,3,4};
printf("%d\n",sizeof(a)); // 16
//sizeof(a)就是数组名单独放在sizeof内部,计算的数组总大小,单位是字节
printf("%d\n",sizeof(a+0)); // 4/8
//a+0 是数组首元素的地址
printf("%d\n",sizeof(*a)); // 4/8
//首元素的地址
printf("%d\n",sizeof(a+1)); // 4/8
//a是数组首元素的地址 -- int*;a+1 跳过1个整型, 是第二个元素的地址
printf("%d\n",sizeof(a[1])); // 4
//一个整型的大小
printf("%d\n",sizeof(&a)); // 4/8
//&a - 取出的是整个数组的地址,但是数组的地址也是地址,是地址大小就是4/8字节
printf("%d\n",sizeof(*&a)); // 16
//四个整型的大小
printf("%d\n",sizeof(&a+1)); // 4/8
//&a --> int (*)[4],&a+1 跳过一个数组
printf("%d\n",sizeof(&a[0])); // 4/8
//取出首元素的地址
printf("%d\n",sizeof(&a[0]+1)); // 4/8
//第二个元素的地址
2. 字符数组
(1)char arr[] = { ‘a’,‘b’,‘c’,‘d’,‘e’,‘f’ };
printf("%d\n", strlen(arr));
//随机值,因为不知道\0的位置
printf("%d\n", strlen(arr + 0));
//随机值
//printf("%d\n", strlen(*arr));
//非法访问
//printf("%d\n", strlen(arr[1]));
//'b' - 98 当成地址,形参非法访问
printf("%d\n", strlen(&arr));
//随机值
printf("%d\n", strlen(&arr + 1));
//随机值
printf("%d\n", strlen(&arr[0] + 1));
//随机值
printf("%d\n", sizeof(arr));//6
printf("%d\n", sizeof(arr + 0));
//arr+0是数组首元素的地址 4/8
printf("%d\n", sizeof(*arr));
//*arr是首元素的,计算的是首元素的大小 1
printf("%d\n", sizeof(arr[1]));//1
printf("%d\n", sizeof(&arr));
//&arr是数组的地址 4/8
printf("%d\n", sizeof(&arr + 1));
//&arr + 1跳过一个数组后的地址,4/8
printf("%d\n", sizeof(&arr[0] + 1));
//4/8 第二个元素的地址
(2)char arr[] = “abcdef”;//[a b c d e f \0]
printf("%d\n", strlen(arr));//6
printf("%d\n", strlen(arr + 0));//6
//printf("%d\n", strlen(*arr));//err
//printf("%d\n", strlen(arr[1]));//err
printf("%d\n", strlen(&arr));//6
//&arr - char (*)[7]
printf("%d\n", strlen(&arr + 1));//随机值
printf("%d\n", strlen(&arr[0] + 1));//5
printf("%d\n", sizeof(arr));//7
printf("%d\n", sizeof(arr + 0));//4/8
printf("%d\n", sizeof(*arr));//*arr -是数组首元素 1
//arr[0] *(arr+0)
//int sz = sizeof(arr)/sizeof(*arr);
//int sz = sizeof(arr)/sizeof(arr[0]);
printf("%d\n", sizeof(arr[1]));//1
printf("%d\n", sizeof(&arr));
//数组的地址,是地址就是4 / 8
printf("%d\n", sizeof(&arr + 1));//4 / 8
printf("%d\n", sizeof(&arr[0] + 1));//4 / 8
(3)char* p = “abcdef”;
printf("%d\n", strlen(p)); //6
printf("%d\n", strlen(p + 1)); //5
//p+1是'b'的地址
//printf("%d\n", strlen(*p));//err
//printf("%d\n", strlen(p[0]));//err
printf("%d\n", strlen(&p));//随机值
printf("%d\n", strlen(&p + 1));//随机值
printf("%d\n", strlen(&p[0] + 1));
printf("%d\n", sizeof(p));//4 / 8
printf("%d\n", sizeof(p + 1));
//'b'的地址,4/8
printf("%d\n", sizeof(*p));//1
printf("%d\n", sizeof(p[0]));
//*(p+0)--'a' 1
printf("%d\n", sizeof(&p));//
printf("%d\n", sizeof(&p + 1));
printf("%d\n", sizeof(&p[0] + 1));
//&p[0]+1是'b'的地址
3. 二维数组
printf("%d\n", sizeof(a));//48
//a这个二维数组的数组名单独放在sizeof内部,计算整个数组的大小
printf("%d\n", sizeof(a[0][0]));
//第一行第一个元素,4个字节
printf("%d\n", sizeof(a[0]));//16
//a[0] 第一行的数组名,这时数组名单独放在sizeof内部了
//计算的是数组的大小,单位是字节,16
printf("%d\n", sizeof(a[0] + 1));//4
//a[0]不是单独放在sizeof内部,a[0]表示的首元素的地址,即第一行第一个元素的地址 - &a[0][0]
//a[0] + 1 是第一行第2个元素的地址 &a[0][1]
printf("%d\n", sizeof(*(a[0] + 1)));
//a[0][1] 大小是:4个字节
printf("%d\n", sizeof(a + 1));
//a作为二维数组的数组名并非单独放在sizeof内部,所以表示首元素的地址
//二维数组的首元素是第一行,这里的a就是第一行的地址--- int (*)[4]
//a+1是跳过第一行,指向了第二行
printf("%d\n", sizeof(*(a + 1)));//16
//*(a+1)-->a[1]
printf("%d\n", sizeof(&a[0] + 1));//4/8
//&a[0]是第一行的地址
//&a[0]+1是第二行的地址
printf("%d\n", sizeof(*(&a[0] + 1)));//16 a[1]
printf("%d\n", sizeof(*a));//16
//*a - 就是第一行
//*a -- *(a+0) -- a[0]
printf("%d\n", sizeof(a[3]));//16
sizeof不会真的改变()内的值,不会真的实现()内的表达式;
int a = 5;
short s = 11;
printf("%d\n", sizeof(s = a + 2));//2
printf("%d\n", s);//11