目录
一、字符指针
指针类型中 char * 为字符指针
一般使用:
int main()
{
char ch = 'w';
char *pc = &ch;
*pc = 'w';
return 0;
}
另一种使用方式:
int main()
{
const char* ptr = "hello world";//常量字符串不能被修改,所以用const修饰
printf("%s", ptr);
return 0;
}
将常量字符串首字符的地址赋值给字符指针ptr, 字符串常量的值是代表存放字符串常量首字符的储存单元的地址,实质上是一个指向该字符串首字符的指针常量。
笔试题:
#include <stdio.h>
int main()
{
char str1[] = "hello world.";
char str2[] = "hello world.";
const char* str3 = "hello world.";
const char* str4 = "hello world.";
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
由于常量字符串不能被修改,所以常量字符串只会在内存中存放一份(只读数据区),当赋值定义时共用该常量字符串。而字符数组与之不同,即使内容相同,也不会共用同一内存空间。
二、指针数组
整型数组——存放整形的数组
字符数组——存放字符的数组
指针数组——存放指针的数组
字符指针数组:
#include <stdio.h>
int main()
{
const char* arr[4] = { "abcdef","qwer","hello world","hehe" };
int i = 0;
for (i = 0; i < 4; i++)
{
printf("%s\n", arr[i]);
}
return 0;
}
//打印
abcdef
qwer
hello world
hehe
整形指针数组:
#include <stdio.h>
int main()
{
int arr1[5] = { 1,2,3,4,5 };
int arr2[5] = { 2,3,4,5,6 };
int arr3[5] = { 3,4,5,6,7 };
int arr4[5] = { 0,0,0,0,0 };
int* arr[4] = { arr1,arr2,arr3,arr4 };
int i = 0;
for (i = 0; i < 4; i++)
{
int j = 0;
for (j = 0; j < 5; j++)
{
printf("%d ", arr[i][j]);
//printf("%d",*(arr[i]+j));
// arr[i] == *(arr + i),与指针数组很像
}
printf("\n");
}
return 0;
}
//打印
1 2 3 4 5
2 3 4 5 6
3 4 5 6 7
0 0 0 0 0
三、数组指针
1.数组指针的定义
整形指针——存放整形地址的指针——指向整形的指针——char *
字符指针——存放字符地址的指针——指向字符的指针——int *
数组指针——存放数组地址的指针——指向数组的指针
int main()
{
char ch = 'w';
char* pc = &ch;
int num = 10;
int* pi = #
int arr[10];
//pa就是一个数组指针
int (*pa)[10] = &arr;
return 0;
}
解释:p先和*结合,说明p是一个指针变量,然后指针指向的是一个大小为10个整型的数组。所以p是一个指针,指向一个数组,叫数组指针。(理解)
这里要注意:[ ] 的优先级要高于*号的,所以必须加上()来保证p先和*结合。
int (*p)[10] = arr;//错误
这样写是错误写法,是不合理的,因为arr数组名代表数组首元素地址,是int*,而此时p的类型是int(*)[10],两者类型不同
2.&数组名与数组名
#include <stdio.h>
int main()
{
int arr[10] = { 0 };
printf("%p\n", arr);
printf("%p\n", &arr);
return 0;
}
可以发现数组首元素的地址和数组的地址从值的角度来看是相同的,但它们所代表的意义不同:
我们知道指针类型不同,指针+1或-1,指针移动的字节数不同,故
#include <stdio.h>
int main()
{
int arr[10] = { 0 };
printf("arr = %p\n", arr);
printf("&arr= %p\n", &arr);
//printf("%p\n", &arr[0]);//int*
//printf("%p\n", &arr[0]+1);//4
printf("arr+1 = %p\n", arr + 1);
printf("&arr+1= %p\n", &arr + 1);
return 0;
}
//例如
char arr[5];
char (*pc)[5] = &arr;
// (*pc)代表pc为指针,因为它要接收数组的地址,[5]代表pc指向的是数组,数组有6个元素,每个元素为char
3.数组指针的使用
学习了数组指针,那么数组指针有什么用处,该怎么用呢?
一种鸡肋用法:
#include <stdio.h>
int main()
{
int arr[10] = { 1,2,3,4,5,6,7,8,9,0 };
int(*p)[10] = &arr;//把数组arr的地址赋值给数组指针变量p
//但是我们一般很少这样写代码
int i = 0;
for (i = 0; i < 10; i++)
{
printf("%d ", (*p)[i]);
}
return 0;
}
//打印
1 2 3 4 5 6 7 8 9 10
p表示数组的地址,它有能力访问所有元素,(*p)表示解引用指针,表示数组首元素的地址,* ( ( *p) + i)表示第几个元素。
一个数组指针的使用:
#include <stdio.h>
void print_arr1(int arr[3][5], int row, int col)
{
int i = 0;
for (i = 0; i < row; i++)
{
for (j = 0; j < col; j++)
{
printf("%d ", arr[i][j]);
}
printf("\n");
}
}
void print_arr2(int(*arr)[5], int row, int col)
{
int i = 0;
for (i = 0; i < row; i++)
{
for (j = 0; j < col; j++)
{
printf("%d ", arr[i][j]);
}
printf("\n");
}
}
int main()
{
int arr[3][5] = { 1,2,3,4,5,6,7,8,9,10 };
print_arr1(arr, 3, 5);
//数组名arr,表示首元素的地址
//但是二维数组的首元素是二维数组的第一行
//所以这里传递的arr,其实相当于第一行的地址,是一维数组的地址
//可以数组指针来接收
print_arr2(arr, 3, 5);
return 0;
}
二维数组是一维数组的一维数组,二维数组名就是第一行的地址,不是a[0][0]的地址,是数组的地址,类型为 int(*)[ ] 。arr + i 是第i行的地址,*(arr + i) 是第i行第一个元素的地址 *( * ( arr + i ) + j) 就是第 i 行第 j 列的元素。
所以,一个二维数组传参,形参可以是数组指针也可以是二维数组。
在学习了指针数组与数组指针,看下面四个定义,解释定义的类型是什么。
int arr[5];
int* parr1[10];
int(*parr2)[10];
int(*parr3[10])[5];
- 整型数组,数组是5个元素
- 指针数组, 数组10个元素,每个元素是int *类型
- 数组指针,指针指向一个数组,数组是10个元素,每个元素是int
- 数组指针数组,parr3先与 [ ]结合,是数组,数组有十个元素,每个元素是 int( * )[ 5 ]
四、数组参数、指针参数
1.一维数组传参
#include <stdio.h>
void test(int arr[])//ok? OK 可以不指定数组大小
{}
void test(int arr[10])//ok? OK
{}
void test(int* arr)//ok? OK
{}
void test2(int* arr[20])//ok? OK
{}
void test2(int** arr)//ok? OK
{}
int main()
{
int arr[10] = { 0 };
int* arr2[20] = { 0 };
test(arr);
test2(arr2);//指针数组名,二级指针
}
2.二维数组传参
void test(int arr[3][5])//ok? OK
{}
void test(int arr[][])//ok? NO
{}
void test(int arr[][5])//ok? OK
{}
//总结:二维数组传参,函数形参的设计只能省略第一个[]的数字。
//因为对一个二维数组,可以不知道有多少行,但是必须知道一行多少元素。
//这样才方便运算。
void test(int *arr)//ok? NO
{}
void test(int* arr[5])//ok? NO
{}
void test(int (*arr)[5])//ok? OK
{}
void test(int **arr)//ok? NO
{}
int main()
{
int arr[3][5] = {0};
test(arr);
}
总结:二维数组传参,函数形参的设计只能省略第一个[ ]的数字,因为对一个二维数组,可以不知道有多少行,但是必须知道一行多少元素,这样才方便运算。
分析传过来的是什么,就可判断。
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;
}
思考:
当一个函数的参数部分为一级指针的时候,函数能接收什么参数?
- 一维数组数组名
- 一级指针
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;
}
思考:当函数的参数为二级指针的时候,可以接收什么参数?
- 二级指针
- 一级指针的地址
- 指针数组名
void test(char** p)
{
}
int main()
{
char c = 'b';
char* pc = &c;
char** ppc = &pc;
char* arr[10];
test(&pc);
test(ppc);
test(arr);//Ok?
return 0;
}
五、函数指针
#include <stdio.h>
void test()
{
printf("hehe\n");
}
int main()
{
printf("%p\n", test);
printf("%p\n", &test);
return 0;
}
输出的是两个地址,这两个地址是 test 函数的地址。&函数名与函数名都是函数的地址.
那我们的函数的地址要想保存起来,怎么保存?
下面我们看代码:
int add(int x, int y)
{
return x +y ;
}
void test()
{
printf("hehe\n");
}
int (*pf)(int, int) = &add;
下面pfun1和pfun2哪个有能力存放test函数的地址?
void (*pfun1)();
void *pfun2();
首先,能给存储地址,就要求pfun1或者pfun2是指针,那哪个是指针?答案是:pfun1可以存放。pfun1先和*结合,说明pfun1是指针,指针指向的是一个函数,指向的函数无参数,返回值类型为void。
- 使用()将pf先于*结合,表示指针,再写指针指向函数的参数类型,返回值类型。
- 使用指针访问函数时,还是()将pf与*结合,又此时是函数,函数需要传参,再用()传参。
其实在调用函数指针时,pf 前面可以不写*,因为定义函数指针后,pf相当于add函数的别名,函数名可以直接使用,那么函数指针也是可以直接使用的,简单地说,前面的*是没有用的,即使是n个*也还是正常使用,但是如果非要使用(*pf)形式的话,必须加()保证优先级,如果*pf不是用括号,那么由于优先级顺序,会造成一些问题。
int (* pf)(int, int) = add;
int ret = pf(2, 3);
int ret = (*pf)(2, 3);
结果都是5,两式等价
下面,我们来阅读两段有趣的代码:
//代码1
(*(void (*)())0)();
//代码2
void (*signal(int, void(*)(int)))(int);
- 改代码是调用0地址处的函数,是一次函数调用,首先 ( void (*) () ) 0将整型0强转为函数指针类型 void (*)(),再调用0地址处函数
- 该代码是一次函数的声明,声明的函数名字叫 signal,函数 signal 的参数有两个,第一个是int类型参数,第二个是函数指针类型参数,并且该函数指针能指向的那个函数返回类型是void,函数参数是int类型,而signal函数的返回类型是一个函数指针,可以理解为
void (*)(int) signal(int, void (*)(int));
但是在语法上,该代码是错误的,它只是有助于我们理解
代码2太复杂,如何简化:
我们知道,typedef可以简化重命名,但是要注意:
typedef void(*)(int) pf_t;
上面这个重命名形式在语法上是错误的,重命名的名字应放在括号里。 (其他重命名规则依旧,这里特殊)
typedef void(*pf_t)(int);
pf_t signal(int, pfun_t);
例题:
定义一个函数指针,指向的函数有两个int形参并且返回一个函数指针,返回的指针指向一个有一个int形参且返回int的函数。
类比上面第二题,要注意,第二题是函数声明,而该例题是定义函数指针
int (*(*f)(int, int))(int);
六、函数指针数组
我们知道,整型指针是指向整型的指针,数组指针是指向数组的指针,其实,函数指针就是指向函数的指针。和学习数组指针一样,学习函数指针我们也需要知道三点:
- ( )的优先级要高于 * 。
- 一个变量除去了变量名,便是它的变量类型。
- 一个指针变量除去了变量名和 * ,便是指针指向的内容的类型。
int *arr[10];
//数组的每个元素是int*
那要把函数的地址存到一个数组中,那这个数组就叫函数指针数组,那函数指针的数组如何定义呢?
int (*parr1[10])();
int *parr2[10]();
int (*)() parr3[10];
例子:(计算器)
#include <stdio.h>
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, y;
int input = 1;
int ret = 0;
do
{
printf("*************************\n");
printf(" 1:add 2:sub \n");
printf(" 3:mul 4:div \n");
printf("*************************\n");
printf("请选择:");
scanf("%d", &input);
switch (input)
{
case 1:
printf("输入操作数:");
scanf("%d %d", &x, &y);
ret = add(x, y);
printf("ret = %d\n", ret);
break;
case 2:
printf("输入操作数:");
scanf("%d %d", &x, &y);
ret = sub(x, y);
printf("ret = %d\n", ret);
break;
case 3:
printf("输入操作数:");
scanf("%d %d", &x, &y);
ret = mul(x, y);
printf("ret = %d\n", ret);
break;
case 4:
printf("输入操作数:");
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;
}
#include <stdio.h>
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, y;
int input = 1;
int ret = 0;
int(*p[5])(int x, int y) = { 0, add, sub, mul, div }; //转移表
while (input)
{
printf("*************************\n");
printf(" 1:add 2:sub \n");
printf(" 3:mul 4:div \n");
printf("*************************\n");
printf("请选择:");
scanf("%d", &input);
if ((input <= 4 && input >= 1))
{
printf("输入操作数:");
scanf("%d %d", &x, &y);
ret = (*p[input])(x, y);
}
else
printf("输入有误\n");
printf("ret = %d\n", ret);
}
return 0;
}
七、指向函数指针数组的指针
指向函数指针数组的指针是一个指针,指针指向一个数组 ,数组的元素都是函数指针 ;
如何定义?
既然存在函数指针数组,那么必然存在指向函数指针数组的指针。
int(*p)(int, int);
//函数指针
int(*pArr[5])(int, int);
//函数指针数组
int(*(*pa)[5])(int, int) = &pArr;
//指向函数指针数组的指针
void test(const char* str)
{
printf("%s\n", str);
}
int main()
{
//函数指针pfun
void (*pfun)(const char*) = test;
//函数指针的数组pfunArr
void (*pfunArr[5])(const char* str);
pfunArr[0] = test;
//指向函数指针数组pfunArr的指针ppfunArr
void (*(*ppfunArr)[5])(const char*) = &pfunArr;
return 0;
}
八、回调函数
1. 回调函数概念
首先演示一下qsort函数的使用:
#include <stdio.h>
//qosrt函数的使用者得实现一个比较函数
int int_cmp(const void * p1, const void * p2)
{
return (*( int *)p1 - *(int *) p2);
}
int main()
{
int arr[] = { 1, 3, 5, 7, 9, 2, 4, 6, 8, 0 };
int i = 0;
qsort(arr, sizeof(arr) / sizeof(arr[0]), sizeof (int), int_cmp);
for (i = 0; i< sizeof(arr) / sizeof(arr[0]); i++)
{
printf( "%d ", arr[i]);
}
printf("\n");
return 0;
}
使用回调函数,模拟实现qsort(采用冒泡的方式)
#include <stdio.h>
int int_cmp(const void* p1, const void* p2)
{
return (*(int*)p1 - *(int*)p2);
}
void _swap(void* p1, void* p2, int size)
{
int i = 0;
for (i = 0; i < size; i++)
{
char tmp = *((char*)p1 + i);
*((char*)p1 + i) = *((char*)p2 + i);
*((char*)p2 + i) = tmp;
}
}
void bubble(void* base, int count, int size, int(*cmp)(void*, void*))
{
int i = 0;
int j = 0;
for (i = 0; i < count - 1; i++)
{
for (j = 0; j < count - i - 1; j++)
{
if (cmp((char*)base + j * size, (char*)base + (j + 1) * size) > 0)
{
_swap((char*)base + j * size, (char*)base + (j + 1) * size, size);
}
}
}
}
int main()
{
int arr[] = { 1, 3, 5, 7, 9, 2, 4, 6, 8, 0 };
//char *arr[] = {"aaaa","dddd","cccc","bbbb"};
int i = 0;
bubble(arr, sizeof(arr) / sizeof(arr[0]), sizeof(int), int_cmp);
for (i = 0; i < sizeof(arr) / sizeof(arr[0]); i++)
{
printf("%d ", arr[i]);
}
printf("\n");
return 0;
}
九、指针笔试题
int main()
{
int a[5] = { 1, 2, 3, 4, 5 };
int *ptr = (int *)(&a + 1);
printf( "%d,%d", *(a + 1), *(ptr - 1));
return 0;
}
//程序的结果是什么?
//由于还没学习结构体,这里告知结构体的大小是20个字节
struct Test
{
int Num;
char *pcName;
short sDate;
char cha[2];
short sBa[4];
}*p;
//假设p 的值为0x100000。 如下表表达式的值分别为多少?
//已知,结构体Test类型的变量大小是20个字节
int main()
{
printf("%p\n", p + 0x1);
printf("%p\n", (unsigned long)p + 0x1);
printf("%p\n", (unsigned int*)p + 0x1);
return 0;
}
int main()
{
int a[4] = { 1, 2, 3, 4 };
int *ptr1 = (int *)(&a + 1);
int *ptr2 = (int *)((int)a + 1);
printf( "%x,%x", ptr1[-1], *ptr2);
return 0;
}
#include <stdio.h>
int main()
{
int a[3][2] = { (0, 1), (2, 3), (4, 5) };
int *p;
p = a[0];
printf( "%d", p[0]);
return 0;
}
int main()
{
int a[5][5];
int(*p)[4];
p = a;
printf( "%p,%d\n", &p[4][2] - &a[4][2], &p[4][2] - &a[4][2]);
return 0;
}
int main()
{
int aa[2][5] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
int *ptr1 = (int *)(&aa + 1);
int *ptr2 = (int *)(*(aa + 1));
printf( "%d,%d", *(ptr1 - 1), *(ptr2 - 1));
return 0;
}
#include <stdio.h>
int main()
{
char *a[] = {"work","at","alibaba"};
char**pa = a;
pa++;
printf("%s\n", *pa);
return 0;
}
int *p;
p+1;
p++是跳过前面的一个char类型,同理char** pa,pa++这里跳过一个char*类型
![](https://i-blog.csdnimg.cn/blog_migrate/9a9127fd9431281dba3c7cfb35b8598d.png)
int main()
{
char *c[] = {"ENTER","NEW","POINT","FIRST"};
char**cp[] = {c+3,c+2,c+1,c};
char***cpp = cp;
printf("%s\n", **++cpp);
printf("%s\n", *--*++cpp+3);
printf("%s\n", *cpp[-2]+3);
printf("%s\n", cpp[-1][-1]+1);
return 0;
}
关键是画图理解