指针基础
一 指针就是地址,地址就是指针.指针存储的是内存的地址.
二 指针的定义
1.&表示取址运算符,&a 可以取到 a 在内存中的地址;打印地址的占位符为(%p),printf(“%p\n”,&a);
2. 指针变量的定义
指针变量是用来存放地址的.
指针定义的格式:
类型数据 *变量名 = 初始值;
int *p = NULL;*在这里表示p 是一个指针变量,不是运算符.
printf(“%p\n”,p); 在打印指针的时候不需要使用取址运算符(&),因为指针本来就是地址.
*p 指针为空时,打印出来0x0的地址,为空.
int a = 10;
p = &a;
printf(“%p\n”,p);
访问内存中的数据有两种方法:
1.直接访问内存中的数据.
printf(“%p\n”,a);
2. 通过指针进行访问.
*也可以作为取值运算符.* p 代表取到 p 指向内存中存储的数据 printf(“%d\n”,*p);
int a = 10,b = 20;
int *p1 = &a;
int *p2 = &b;
对指针重新赋值,意味着指针重指向,也就是说指针指向一个新的地址.
p1 = p2;p1指向 c 的首地址
printf(“*p1 = %d,*p2 = %d\n”,*p1,*p2);
int a = 15,b = 20;
int *p = &a;
int *p1 = &b;
单独的* p 表示取值,* p = 11 表示向 p 指向的内存中存入数据.
*p = 11;
printf(“%d\n”,a);
int *p3 = &a;
p3 = p1;
*p1 = 8;
printf(“a = %d,b = %d\n”,a,b);a = 11,b = 8
经典练习
int a= 6,b= 8,c = 10;
int *x = &a;
x = &c;
int *y = &b;
int *z = &c;
*z = 5;
*x = 12;
x = y;
*y = *x + *z;
printf(“a= %d,b = %d,c = %d\n”,a,b,c);
指针中常见的问题
1.内存编号比较小的存储单元,是由系统控制的,不允许访问.
int *p = NULL;
*p = 100; error
2.野指针,定义时没有赋初始值,操作野指针是很危险的
int *p;
*p = 100;error
3.定义指针时,*怎么写?
int *p= NULL;推荐
int* p1 = NULL;
int *p1 = NULL;
int*p3 = NULL;
4.指针变量在内存中占几个字节
与数据类型无关,在32位操作系统下,指针所占字节数是4位,在64位操作系统中,指针所占字节数是8位.
printf(“%lu\n”,sizeof(long *));
5. 修饰指针变量数据类型的作用
a. 指针变量数据类型,决定*(取值运算符),取多少个字节的数据;
定义指针的数据类型一定要和指向数据的数据类型一致,这样才能把数据完整的取出来
int *p = NULL;
int a = 268;
p = &a;
printf(“%d\n”,*p);
char *c = NULL;
c = &a;
printf(“%d\n”,*c);
b.指针类型,决定指针变量加1操作时,跳转多少个字节
int *p = NULL;
printf(“%p\n”,p); //0x0
printf(“%p\n”,p+1);//0x4
printf(“%p\n”,p+2);//0x8
printf(“%p\n,p++);//打印的结果是:0x4 但是实际结果是:0x8
p+1 和 p++或++ p 的关系
相同:取到的都是下一个字节的地址
不同:++p和 p++ 造成指针的重指向
6.指针在数组中的应用
int a[5] = {1,2,3,4,5};
数组名就是数组元素的首地址
printf(“%p\n”,a);
printf(“%p\n”,&a[0]);
printf(“%p\n”,p);
printf(“%p\n”,a+1);
printf(“%p\n”,&a[1]);
printf(“%p\n”,p+1);
printf(“%p\n”,a+2);
printf(“%p\n”,&a[2]);
printf(“%p\n”,p+2);
printf(“%d\n”,*a);
printf(“%d\n”,*(a +1));
printf(“%d\n”,*(a+2));
用指针遍历数组
for(int i= 0;i < 5;i++){
printf(“%d\n”,*(a+i));
}
定义指针变量访问数组中的元素
int *p =NULL;
p = a;
printf(“%p\n”,a);
printf(“%p\n”,p);
printf(“%d\n”,*p);
printf(“%d\n”,*(p+1));
printf(“%d\n”,*(p+2));
练习
有10个元素的数组,通过指针变量为元素随机赋值[22 33]
7.数组名(数组元素的首地址) 与指向数组首地址的指针变量的区别:
a. 数组名(数组首地址) 是一个常量地址不能被修改
a = NULL;error
指针变量可以修改,可以重指向
b. 数组名(数组的首地址),用sizeof 计算得到的结果,整个数组所占的字节数,而用 sizeof 计算指向数组元素首地址的指针变量得到是一个定值4或者8
printf(“%lu\ n”,sizeof(c));
//定义一个10个元素的数组,通过指针变量为元素随机赋值[22 33],冒泡排序;
8.指针在字符串中的应用
用% s 打印是从指针指向那个地址开始向后输出
char string[] = “Canglaoshi”;
printf(“%s\n”,string);
printf(“%s\n”,string+1);
通过指针访问里面的元素
数组名(数组元素的首地址) == 指针
*(string + 3) = ‘\0'
printf(“%s\ n”,string);
通过指针访问元素
printf(“%c\ n”,*(string +3));
通过指针计算字符串的长度
int i= 0;
*(string +i) 取到数组中对应位置的值
while(*(string+i) != ‘\0’){//string[i]
i++;
}
printf(“%d\n”,i);
指针变量一定要和指向的数据类型相同
char *p = string;
int i = 0;
while(*(p+i) != ‘\0’){
i++;
}
char string[] = "canglaoshi I love you";//将字符串的首个字母大写,并且将空格换成下划线
char string[] = "canglaoshi I love you";
*string -= 32;
char *p = string;
if (string[0] >= 'a' && string[0] <='z') {
string[0] -= 32;
}
int i = 0;
while (*(string+i) != '\0') {
if (*(string + i) == ' ') {
*(string + i) = '-';
}
i++;
}
printf("%s\n",string);
//写一个函数实现两变量的交换
int a = 10;
int b = 20;
change(&a,&b);
printf("a = %d,b = %d\n",a,b); int a = 10,b = 20; int sum = 0,sub = 0;
sum = sumAndsub(a,b,&sub); printf("sum = %d,sub = %d\n",sum,sub); float a[10] = {0}; for (int i = 0; i < 10; i++) {
*(a+i) =arc4random()%21+10;
printf("%.2f ",*(a+i));
} printf("\n"); for (int i = 0; i < 10 - 1; i++) { for (int j = 0; j < 10 - i - 1;j++) {// if (a[j] > a[j + 1]) {// float temp = 0;// temp = a[j];// a[j] = a[j + 1];// a[j + 1] = temp;// } if (*(a + j) > *(a + 1 + j)) { float temp = 0;
temp = *(a +j);
*(a + j) = *(a + j + 1);
*(a + j + 1) = temp;
}
}
} printf("\n"); for (int i = 0; i < 10; i++) {
printf("%.2f ",*(a+i));
}
结构体指针
1.形参和实参的区别
a. 形参:定义的时候写的参数,(起一个描述的作用,没有实际的意义)
b. 实参:函数实际调用时传进来的参数
形参和实参的传递是单向的.
2.结构体嵌套
在定义结构体的时候,结构体的成员变量也可以是结构体.
3.结构体指针
指向结构体的指针叫结构体指针.
数据类型 + * +变量名 + 初始值;
Student stu1 = {“lisi”,’M’,29};
指针变量指向结构体变量的首地址,相当于指向结构体第一个成员变量的地址
Student *p = &stu1;
结构体指针的访问
printf(“%s”,(*p).name);
通过指针变量访问结构体变量的成员
printf(“%s,%c,%d\n”,p->name,p->sex,p->age);
4——>:指向操作符
只有定义的是结构体变量的首地址,才可以使用(—>指向操作符)访问结构体变量
printf(“%s,%c,%d\n”,p->name,p->sex,p->age);
5.float x1 = 0.1;
float x2 = 1.;
float x3 = 1.f;
float x4 =1.0f;
float x5 = 1;
6.结构体数组与指针的关系
结构体数组的数组名是一个结构体指针常量.
int a[5] = {1,2,3,4,5};
int *p = a;//数组名就是数组的首地址.
printf(“%d\n”,*p);
*stu : stu[0] //代表的都是数组中第一个元素,
*(stu + 1) :stu[1] // 代表的都是数组中的第二个元素.
*(stu + 2) :stu[2] //代表的是数组中的第三个元素.
访问数组中结构体元素的属性
*stu.name :stu[0].name
(*(stu + 1)).name : stu[1].name
—>:指向操作符 :使用的时候一定要保证指针指向结构体变量的首地址
stu—> name :stu[0].name
(stu + 1) —>name :stu[1].name
(stu + 2)——>name : stu[2].name
7.遍历结构体数组的时候,需要向函数中传入数组和长度.
8.指针数组(也就是指向指针的指针)
int a= 3,b = 4,c= 5;
数组中的元素都是指针(地址)数组,就是指针数组.
int *array[3] = {&a,&b,&c};//3*8个字节
printf(“%p\n”,array[0]);
printf(“%p\n”,&a);
printf(“%d\n”,**array);//*array 取到地址 **array 取到地址里的值
printf(“%d\ n”,*(*(arrary + 1)));
二.函数指针
函数指针的声明方法为:
函数类型 (标示符 指针变量名 )(形参列表);
函数类型说明函数的返回类型,”(标识符 指针变量)”中的括号不能省,若省略整体则成为一个函数说明,说明了一个返回的数据类型是指针的函数,后面的”形参列表"表示指针变量指向的函数所带来的参数列表.
例如:
int func(int x); 声明一个函数
int (*f)(int x);
函数指针
1.函数指针类型的确定步骤
1⃣把函数名换成(*) void (*)() int(*)(int,int)
2⃣如果有参数,把参数名去掉,只保留参数类型 void (*)() int (*)(int,int)
3⃣格式
指针类型 *指针名 = 初始值;
char *p= NULL;
函数指针的类型
返回值类型(*函数指针变量名)(参数类型1,参数类型2.....) = 初始值;
函数后面的()是函数调用符.
注意: 函数指针变量名不能和指针重名
int sum(int a,int b){
return a+b;
}
int (*Sum)(int,int);
Sum = sum;
int y = Sum(3,5);
printf(“%d\n”,y);
同一个函数指针可以指向不同的函数,但是(前提是:函数指针的类型必须一致)
2.typedef 原始类型 新类型;
给函数指针类型起别名
typedef int (*FUN)(int,int);
typedef void (*HELLO)
typedef 返回值类型(*新类型名)(参数类型1,参数类型2.....)
3.函数回调
函数回调:就是用函数指针来调用函数
函数名就是指针,存放的函数的首地址
4.动态排序
就是不断的改变排序的条件,根据不同的条件,调用不同的函数,进行排序.
5.枚举
定义:一组有符号的整形常量,一一列举所有的状态,罗列出所有可能的结果
enum season {
spring,
summer,
autumn,
winter};
printf(“%d\n”,spring);
枚举经常和 swith 合用
枚举间接提高了代码的可读性
将人能识别的表示符,与计算机能识别的数字建立联系
6.宏只做简单的替换,在预编译的时候完成替换
宏命名规范:
1⃣纯大写
2⃣k + 大驼峰
无参宏直接进行定义,有参宏可以使用常量表达式
#define SUM(A,B) ((A) - (B))// 最安全的方式
有参数的宏,只做简单的替换运算,不会判断运算符的优先级
int p = SUM(3 + 7,5 + 6) * 3;//3 + 7 * 5 + 6
7.条件编译
第一种
#ifdef MY
printf(“Hello Word!!");
#else
printf(“明天考试!!");
#endif
特点:如果标示符被# define 过,就会执行代码段1,否则就会执行代码段2
第二种方式
#ifndef 标示符
代码段1
#else
代码段2
#endif
特点:如果标示符没有被#define过,就会执行代码段1;如果被定义过,,就编译代码段2
第三种方式
#if 常量表达式
代码段1
#else
代码段2
#endif
#if MY
printf(“你好蓝欧!!");
#else
printf(“你好中国!!");
#endif
特点:如果常量表达式非0,就执行代码段1,否则执行代码段2
8.const 常量修饰符
被 const修饰的常量是不能重新赋值的
