1.字符指针变量
指针类型为char*类型
int main()
{
//char ch = 'w';
//char* pc = &ch;//pc 是指针变量
char arr[10] = "abcdef";//字符数组,数组的内容是可变的
char* p1 = arr;//
*p1 = 'w';
const char * p2 = "abcdef";//p2不可修改,被const修饰的指针,存放的是一个常量字符串,内容不能修改。
//*p2 = 'w';//err
//%s 打印字符串的时候,需要提供起始地址
printf("%s\n", p1);
printf("%s\n", p2);
printf("%s\n", arr);
return 0;
}
int main()
{
char ch = 'w';
char *pc = &ch;
*pc = 'w';
return 0;
}
int main()
{
const char* pstr = "hello bit.";//这⾥是把⼀个字符串放到pstr指针变量⾥了吗?
printf("%s\n", pstr);
return 0;
}
指针存放的是地址,所以在这里存放的是首元素首字符,也就是h的地址,并不是把“hello bit"这个字符串变量放在pstr里。
#include <stdio.h>
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");yes
if(str3 ==str4)
printf("str3 and str4 are same\n");//yes
else
printf("str3 and str4 are not same\n");
return 0;
}
因为字符str1数组和字符str2数组开辟了两份不同的空间,而字符指针str3和字符指针str4,虽然是开辟了两份不同的空间,但是当编译器运行时,它们共占用一份空间,相同的常量字符串,没必要保存两份,因为常量字符串在被const修饰的指针变量是不能被修改的, 这⾥str3和str4指向的是⼀个同⼀个常量字符串 , 当⼏个指针指向同⼀个字符串的时候,他们实际会指向同⼀块内存。但是⽤相同的常量字符串去初始 化不同的数组的时候就会开辟出不同的内存块。所以str1和str2不同,str3和str4相同。
2.数组指针变量
2.1 数组指针变量的定义
是指针变量
整型指针变量:int *pint;存放的是整型变量的地址,能够指向整形数据的指针。
浮点型指针变量:float * pf;存放浮点型变量的地址,能够指向浮点型数据的指针。
数组指针变量应该是:存放的应该是数组的地址,能够指向数组的指针变量。
int *p1[10];//p1先和[10]结合,所以它是一个指针数组。
int (*p2)[10];
数组指针变量
int (*p)[10];
p先和结合,说明p是一个指针变量变量,然后指针指向的是一个大小为10个整型的数组。所以p是一个指针,指向一个数组,叫数组指针。
这⾥要注意:[]的优先级要⾼于号的,所以必须加上()来保证p先和*结合。
2.2 数组指针变量初始化
&数组名
int arr[10] = {0};
&arr//得到的就是数组的地址
int(*p)[10] = &arr;//这是把地址存放在数组指针变量中
//&arr和p的类型完全是一样的
3.二维数组传参的本质
先看三组一维数组传参
int main()
{
int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
int* p = arr;//把首元素地址arr放在p指针变量中
int i = 0;
for (i = 0; i < 10; i++)
{
printf("%d\n", *p);
p++;
}
return 0;
}
//不好的示范
int main()
{
int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
int (* p)[10] = &arr;//把整个数组的地址放在数组指针变量中
//& *
//*&arr == arr
int i = 0;
for (i = 0; i < 10; i++)
{
printf("%d ", (*p)[i]);
}
return 0;
}
void print(int arr[3][5], int r, int c)
{
int i = 0;
for (i = 0; i < r; i++)
{
int j = 0;
for (j = 0; j < c; j++)
{
printf("%d ", arr[i][j]);
}
printf("\n");
}
}
void print(int (*arr)[5], int r, int c)
{
int i = 0;
for (i = 0; i < r; i++)
{
int j = 0;
for (j = 0; j < c; j++)
{
printf("%d ", *(*(arr + i) + j));//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} };
//数组名是数组首元素的地址
//1. &数组名
//2. sizeof(数组名)
//
print(arr, 3, 5);
return 0;
}
#include <stdio.h>
void test(int a[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 ", a[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}};
test(arr, 3, 5);
return 0;
}
1 | 2 | 3 | 4 | 5 |
---|---|---|---|---|
2 | 3 | 4 | 5 | 6 |
3 | 4 | 5 | 6 | 7 |
二维数组起始可以看作是每个元素是一维数组的数组,也就是二维数组,三个一维数组组成一个二维数组,二维数组的首元素就是第一行,是一个一维数组,&a[1]也就是整个一位数组的地址,
⼆维数组的数组名表⽰的就是第⼀⾏的地址,是⼀ 维数组的地址。根据上⾯的例⼦,第⼀⾏的⼀维数组的类型就是 int [5] ,所以第⼀⾏的地址的类 型就是数组指针类型 int(*)[5] 。那就意味着⼆维数组传参本质上也是传递了地址,传递的是第⼀ ⾏这个⼀维数组的地址,那么形参也是可以写成指针形式的。
#include <stdio.h>
void test(int (*p)[5], int r, int c)
{//int (*p)[5],这是一个数组指针变量,用来接受第一行一维数组的地址
int i = 0;
int j = 0;
for(i=0; i<r; i++)
{
for(j=0; j<c; j++)
{
printf("%d ", *(*(p+i)+j));//*(p+i)遍历3行,*(p+i)+j)//遍历5列
}
printf("\n");
}
}
int main()
{
int arr[3][5] = {{1,2,3,4,5}, {2,3,4,5,6},{3,4,5,6,7}};
test(arr, 3, 5);
return 0;
}
⼆维数组传参,形参的部分可以写成数组,也可以写成指针形式。
4.函数指针变量
4.1 函数指针变量的创建
#include <stdio.h>
void test()
{
printf("hehe\n");
}
int main()
{
printf("test: %p\n", test);
printf("&test: %p\n", &test);
return 0;
}
它们打印的地址是相同的,函数是有地址的,函数名就是函数的地址,也可以通过&函数名的方式获得函数的地址,&函数名==函数名的地址。
如何将函数的地址存放起来,我们需要创建函数指针变量, 函数指针变量的写法其实和数组指针 ⾮常类似。
void test()
{
printf("hehe\n");
}
void (*pf1)() = &test;
void (*pf2)()= test;
int Add(int x, int y)
{
return x+y;
}
int(*pf3)(int, int) = Add;
int(*pf3)(int x, int y) = &Add;//x和y写上或者省略都是可以的
int (*)(int x, int y)//pf3函数指针变量的类型
4.2 函数指针变量的使用
通过函数指针调⽤指针指向的函数。
#include <stdio.h>
int Add(int x, int y)
{
return x+y;
}
int main()
{
int(*pf3)(int, int) = Add;
printf("%d\n", (*pf3)(2, 3));
printf("%d\n", pf3(3, 5));
return 0;
}
二级指针变量是用来存放一级指针变量的地址
int** arr
int main()
{
int a = 10;
int * pa = &a;
int ** ppa = &pa;
return 0;
}
int Add(int x, int y)
{
return x + y;
}
char* test(char c, int n)
{
//...
}
int main()
{
//printf("&Add = %p\n", &Add);
//printf("Add = %p\n", Add);
//int arr[10] = {0};
//int (*pa)[10] = &arr;
//int (*pf)(int,int) = &Add;//pf是专门用来存放函数的地址的,pf就是函数指针变量
char* (*p)(char, int) = &test;
return 0;
}
int Add(int x, int y)
{
return x + y;
}
int main()
{
int (* pf)(int,int) = Add;
int c = Add(2, 3);//函数名调用
printf("%d\n", c);
int d = (*pf)(3, 4);//函数指针调用
printf("%d\n", d);
int e = pf(4, 5);//函数指针调用
printf("%d\n", e);
return 0;
}
4.3 有趣的代码
(*(void (*)())0)();
( * ( void (*)() ) 0 )();
//void(*)()--函数指针类型
//( void (*) )--强制类型转换
//( void (*)() ) 0--将整型0强制类型转换为void(*)()的函数指针类型。
//把整型0强制类型转换为void*类型,参数是无参,返回类型是void。
//最终调用0地址处放的整个函数
//函数声明
void (*signal(int , void(*)(int)))(int);
signal (int ,void(*)int))
//函数名 参数1整型 参数2函数指针
//返回类型是函数指针类型
void(* )(int);//返回类型
4.3.1 typedef关键字
typedef 是⽤来类型重命名的,类型重定义,可以将复杂的类型,简单化。
typedef unsigned int uint;
//将unsigned int 重命名为uint
指针类型重命名
typedef int* ptr_t;//将int* 重命名为ptr_t;
数组指针和函数指针区别
数组指针类型
typedef int(*parr_t)[5];//数组指针类型int(*)[5],需要重命名parr_t,新的类型名必须在*的右边
函数指针类型
typedef void(*pfun_t)(int);//将 void(*)(int) 类型重命名为 pf_t ,新的类型名必须在*的右边。
typedef void(*pfun_t)(int);
pfun_t signal(int, pfun_t);
5.函数指针数组
元素为函数指针的数组。转移表。c语言中函数不可以定义为数组,只能通过定义函数指针来操作。
int *arr[10];
//数组的每个元素是int*
//把函数的地址存到⼀个数组中,那这个数组就叫函数指针数组
int (*parr1[3])();
int *parr2[3]();
int (*)() parr3[3];
parr1先和[]结合,说明parr1是数组,数组的内容是int(*) ()类型的函数指针。
6.转移表
计算器的实现
#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(" 0:exit \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 }; //转移表
do
{
printf("*************************\n");
printf(" 1:add 2:sub \n");
printf(" 3:mul 4:div \n");
printf(" 0:exit \n");
printf("*************************\n");
printf( "请选择:" );
scanf("%d", &input);
if ((input <= 4 && input >= 1))
{
printf( "输⼊操作数:" );
scanf( "%d %d", &x, &y);
ret = (*p[input])(x, y);
printf( "ret = %d\n", ret);
}
else if(input == 0
{
printf("退出计算器\n");
}
else
{
printf( "输⼊有误\n" );
}
}while (input);
return 0;
}