C/C++指针
为什么要使用指针
函数的值传递,无法通过调用函数,来修改函数的实参;被调用函数需要提供更多的“返回值”给调用函数;减少值传递时带来的额外开销,提高代码执行效率
指针定义:指针是什么
int age=18;
/* 定义了一个指针,指针本身也是一个变量,名称是 p,
它是一个指针,可以指向一个整数。
也就是说: p 的值就是一个整数的地址!!! */
int *p ;
//指针 p 指向了 age,p 的值,就是 age 的地址
p = &age;
指针的定义
int *p; // int *p1, *p2;
int* p; // int* p1,p2; //p1 是指针, p2 只是整形变量
int * p;
int*p; //不建议
指针的初始化、访问
指针的初始化
int room = 2;
//定义两个指针变量指向 room
int *p1 = &room;
int *p2 = &room;
printf("room 地址:%p\n", &room);
printf("p1 地址:%p\n", &p1);
printf("room 所占字节:%d\n", sizeof(room));
printf("p1 所占字节:%d\n", sizeof(p1));
注意: 32 位系统中,int 整数占 4 个字节,指针同样占 4 个字节。64 位系统中,int 整数占 4 个字节,指针占 8 个字节
%p、0x%x、0x%X//使用 16 进制打印,把地址值当成一个无符号数来处理。
指针的访问
int room = 2 ;
int * girl = &room;
int x = 0;
x = *girl;
// & 是取地址符
// *是一个特殊的运算符,*girl 表示读取指针 girl 所指向的
//变量的值, *girl 相当于 room
空指针和野指针
空指针:就是值为 0 的指针。(任何程序数据都不会存储在地址为 0 的内存块中,它是被操作系
统预留的内存块。)
指针初始化为空指针: int *p = 0; 或者 int *p = NULL; //强烈推荐,目的就是,避免访问非法数据
指针不再使用时,可以设置为空指针。
int *select = &xiao_long_lv;
//和小龙女约会
select = NULL;
表示这个指针还没有具体的指向,使用前进行合法性判断
int *p = NULL;
// 。。。。
if (p) { //p 等同于 p!=NULL
//指针不为空,对指针进行操作
}
野指针指:指向无效内存地址的指针,通常是由于指针未被初始化、指向已释放的内存,或越界访问导致的。
//情形一 没有初始化
int *select; //情形二 内存不确定
select = 100;
printf("选择的房间是: %d\n", *select);
const修饰使用:渣值暖超
#include <stdio.h>
#include <stdlib.h>
//const 和指针int main(void){int wife = 24;int girl = 18;//第一种 渣男型int * zha_nan = &wife;*zha_nan = 25;zha_nan = &girl;*zha_nan = 19;printf("girl : %d,wife: %d\n", girl, wife);//第二种 直男型 不能修改指向变量的值//const int * zhi_nan = &wife; //第一种写法int const * zhi_nan = &wife; // 第二种写法*zhi_nan = 26;printf("直男老婆的年龄:%d\n", *zhi_nan);zhi_nan = &girl;printf("直男女朋友的年龄:%d\n", *zhi_nan);//*zhi_nan = 20;//第三种 暖男型 不允许指向别的地址int * const nuan_nan = &wife;*nuan_nan = 26;printf("暖男老婆的年龄:%d\n", wife);//nuan_nan = &girl;//第四种超级暖男型 不允许指向别的地址,不能修改指向变量的值const int * const super_nuan_nan = &wife;//*super_nuan_nan = 28;//super_nuan_nan = &girl;system("pause");return 0;
}
总结: 看 const 离类型(int)近,还是离指针变量名近,离谁近,就修饰谁,谁就不能变
指针的算术运算
指针自增运算
p++ 是在 p 当前地址的基础上 ,自增 p 对应类型的大小,也就是说 p = p+ 1*(sizeof(类型))
指针自减运算
#include <stdio.h>
#include <stdlib.h>
#include <string.h>/*
* 让用户输入一个字符串,然后反向输出,注意:不能改变原来的字符串!
* 如: "12345" 逆转成
"54321" 输出
*/int main(void)
{char input[128];int len;char tmp;scanf_s("%s", input, 128);len = strlen(input);//方法 1 交换/* for( int i=0; i<len/2; i++){tmp = input[i];input[i] = input[len-i-1];input[len-i-1] = tmp;}*//*for(int i=0; i<len; i++){printf("%c", input[i]);}*///printf("逆转后:%s\n", input);//第二种方法/*for(int i=0; i<len; i++){printf("%c", input[len-i-1]);}printf("\n");*///第三种方法char *p = &input[len-1];for(int i=0; i<len; i++){printf("%c", *p--);}printf("\n");system("pause");return 0;
}
指针与整数之间的加减运算
#include <stdio.h>
#include <stdlib.h>
#include <string.h>int main(void){int ages[] = {20,18,19,24,23,28,30,38, 35, 32};int len = sizeof(ages) / sizeof(ages[0]);int *p = ages;printf("第 7 个的年龄: %d\n", *(p+6));//30printf("*p+6 = : %d\n", *p+6);//26printf("第 3 个的年龄: %d\n", *(p+2));int *p1 = &ages[4];printf("相对于第 5 个,她的前一位的年龄: %d\n", *(p1 -1));printf("相对于第 5 个,她的前三位的年龄: %d\n", *(p1 -3));system("pause");return 0;
}
指针与整数的运算,指针加减数字表示的意义是指针在数组中位置的移动;对于整数部分而言,它代表的是一个元素,对于不同的数据类型,其数组的元素占用的字节是不一样的,比如指针 + 1,并不是在指针地址的基础之上加 1 个地址,而是在这个指针地址的基础上加 1 个元素占用的字节数:如果指针的类型是 char*,那么这个时候 1 代表 1 个字节地址;如果指针的类型是 int*,那么这个时候 1 代表 4 个字节地址;如果指针的类型是 float*,那么这个时候 1 代表 4 个字节地址;如果指针的类型是 double*,那么这个时候 1 代表 8 个字节地址。
通用公式: 数据类型 *p;p + n 实际指向的地址:p 基地址 + n * sizeof(数据类型);p - n 实际指向的地址:p 基地址 - n * sizeof(数据类型)
比如:对于 int 类型,比如 p 指向 0x0061FF14,则:p+1 实际指向的是 0x0061FF18,与 p 指向的内存地址相差 4 个字节;p+2 实际指向的是 0x0061FF1C,与 p 指向的内存地址相差 8 个字节
对于 char 类型,比如 p 指向 0x0061FF28,则:p+1 实际指向的是 0x0061FF29,与 p 指向的内存地址相差 1 个字节;p+1 实际指向的是 0x0061FF2A,与 p 指向的内存地址相差 2 个字节;
指针与指针之间的加减运算
知识点:指针和指针可以做减法操作,但不适合做加法运算;指针和指针做减法适用的场合:两个指针都指向同一个数组,相减结果为两个指针之间的元素数目,而不是两个指针之间相差的字节数。
//比如:
int int_array[4] = {12, 34, 56, 78};
int *p_int1 = &int_array[0];
int *p_int2 = &int_array[3];
//p_int2 - p_int1 的结果为 3,即是两个之间之间的元素数目为 3 个。
如果两个指针不是指向同一个数组,它们相减就没有意义。不同类型的指针不允许相减,比如
char *p1;int *p2;p2-p1 是没有意义的。
二级指针
二级指针也是一个普通的指针变量,只是它里面保存的值是另外一个一级指针的地址
定义:
int guizi1 = 888;//1 级指针,保存 guizi1 的地址
int *guizi2 = &guizi1; //2 级指针,保存 guizi2 的地址,guizi2 本身是一个一级指针变量
int **liujian = &guizi2;
二级指针的用途:
1. 普通指针可以将变量通过参数“带入”函数内部,但没办法将内部变量“带出”函数
2. 二级指针可以不但可以将变量通过参数函数内部,也可以将函数内部变量 “带出”到函数外部。
#include <stdio.h>
#include <stdlib.h>void swap(int *a, int *b){int tmp =*a;*a= *b;*b= tmp;
}void boy_home(int **meipo){static int boy = 23;*meipo = &boy;
}int main(void){//int x=10, y=100;//swap(&x, &y);//printf("x=%d, y=%d\n", x, y);int *meipo = NULL;boy_home(&meipo);printf("boy: %d\n", *meipo);system("pause");return 0;
}
多级指针的定义、使用
可以定义多级指针指向次一级指针
//比如:
int guizi1 = 888;
int *guizi2 = &guizi1;
//普通指针int **guizi3 = &guizi2;
//二级指向一级int ***guizi4 = &guizi3;
//三级指向二级int ****guizi5 = &guizi4; //四级指向三级
// 有完没完。。。
指针和数组的纠缠
1. 指针表示法和数组表示法
数组完全可以使用指针来访问, days[3] 和 *(days+3) 等同
2. 存储指针的数组[指针数组]
定义: 类型 *指针数组名[元素个数] ;
int *qishou[2]; //定义一个有两个元素的指针数组,每个元素都是一个指针变量
指针和二维数组
1. 指向数组的指针【数组指针】
int (*p)[3]; //定义一个指向三个成员的数组的指针
访问元素的两种方式:数组法:(*p)[j]、指针法:*((*p)+j)
2. 使用普通指针访问二维数组
A[0]
的含义:A
是一个二维数组,A[0]
表示它的第 0 行(即 A[0][0]
、A[0][1]
、A[0][2]
)。在 C/C++ 中,A[0]
会被隐式转换为 &A[0][0]
,即第 0 行的首地址(也就是 A[0][0]
的地址)。&A[0][0]
的含义:直接取 A[0][0]
的地址,显然也是指向二维数组的第一个元素。
数组与指针的区别
数组:数组是用于储存多个相同类型数据的集合。
指针:指针是一个变量,但是它和普通变量不一样,它存放的是其它变量在内存中的地址。
1. 赋值
数组:只能一个一个元素的赋值或拷贝
指针:指针变量可以相互赋值
2. 表示范围
数组有效范围就是其空间的范围,数组名使用下表引用元素,不能指向别的数组
指针可以指向任何地址,但是不能随意访问,必须依附在变量有效范围之内
3. sizeof
数组:
数组所占存储空间的内存:sizeof(数组名)
数组的大小:sizeof(数组名)/sizeof(数据类型)
指针:
在 32 位平台下,无论指针的类型是什么,sizeof(指针名)都是 4.
在 64 位平台下,无论指针的类型是什么,sizeof(指针名)都是 8.
4. 指针数组和数组指针
针指数组:
int *qishou[2];//定义一个有两个元素的指针数组,每个元素都是一个指针变量
int girl1= 167;
int girl2 = 171;
qishou[0] = &girl1;
qishou[1] = &girl2;
数组指针:
int (*p)[3]; //定义一个指向三个成员的数组的指针
访问元素的两种方式:
int A[4][3]={{173, 158, 166},
{168, 155, 171},
{163, 164, 165},
{163, 164, 172}};
p = &A[0];
数组法: (*p)[j]
指针法: *((*p)+j)
5. 传参
数组传参时,会退化为指针!
(1)退化的意义:C 语言只会以值拷贝的方式传递参数,参数传递时,如果只拷贝整个数
组,效率会大大降低,并且在参数位于栈上,太大的数组拷贝将会导致栈溢出。
(2)因此,C 语言将数组的传参进行了退化。将整个数组拷贝一份传入函数时,将数组名
看做常量指针,传数组首元素的地址。
#include <stdio.h>
#include <stdlib.h>
/*------------------ <一维数组传参> -----------------------*/
/*方式一: 形参不指定数组大小
用数组的形式传递参数,不需要指定参数的大小,
因为在一维数组传参时,形参不会真实的创建数组,
传的只是数组首元素的地址。
*/
void method_1(int arr[], int len)
{for(int i=0; i<len; i++){printf(" arr[%d] = %d\n", i, arr[i]);}
}//方式二:指定数组大小
void method_2(int arr[10])
{for(int i=0; i<10; i++){printf(" arr[%d] = %d\n", i, arr[i]);}
}//方式三: 一维数组传参退化,用指针进行接收,传的是数组首元素的地址
void method_3(int *arr, int len){for(int i=0; i<len; i++){printf(" arr[%d] = %d\n", i, arr[i]);}
}int main(){int arr[10] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};method_1(arr, 10);printf("------华丽的分隔线------\n");method_2(arr);printf("------华丽的分隔线------\n");method_3(arr, 10);system("pause");return 0;
}
#include <stdio.h>
#include <stdlib.h>/*-------------------- <指针数组传参> -----------------------*/
//方式一: 指针数组传参,声明成指针数组,不指定数组大小
void method_4(int *arr[], int len){for(int i=0; i<len; i++){printf(" arr[%d] = %d\n", i, *arr[i]);}
}//方式二: 指针数组传参,声明成指针数组,指定数组大小
void method_5(int *arr[10]){for(int i=0; i<10; i++){printf(" arr[%d] = %d\n", i, *arr[i]);}
}//方式三: 二维指针传参
//传过去是指针数组的数组名,代表首元素地址,而数组的首元素又是一个指针,
//就表示二级指针,用二级指针接收
void method_6(int **arr, int len){for(int i=0; i<len; i++){printf(" arr[%d] = %d\n", i, *(*(arr+i)));}
}int main(){int arr[10] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};int *arr_p[10] = {0};for(int i=0; i<10; i++){arr_p[i] = &arr[i];}method_4(arr_p, 10);printf("------华丽的分隔线------\n");method_5(arr_p);printf("------华丽的分隔线------\n");method_6(arr_p, 10);system("pause");return 0;
}
void 类型指针
void => 空类型 void* => 空类型指针,只存储地址的值,丢失类型,无法访问,要访问其值,我们必须对这个指针做出正确的类型转换,然后再间接引用指针。所有其它类型的指针都可以隐式自动转换成 void 类型指针,反之需要强制转换。
#include <stdio.h>
#include <stdlib.h>int main(void){int arr[]={1, 2, 3, 4, 5};char ch = 'a';void *p = arr;//定义了一个void 类型的指针//p++; //不可以,void * 指针不允许进行算术运算p = &ch; //其它类型可以自动转换成void * 指针//printf("数组第一个元素: %d\n", *p); //不可以进行访问printf("p: 0x%p ch: 0x%p\n", p, &ch);char * p1 = (char *)p; //强制类型转化printf("p1 指向的字符是: %c\n", *p1);system("pause");return 0;
}
函数指针
#include <stdio.h>
#include <stdlib.h>
#include <string.h>int compare_int(const void *a, const void *b){//printf("调用compare_int 啦,你好骚气哦! \n");int *a1 = (int *) a;int *b1 = (int *) b;//printf("a 的地址: 0x%p b的地址: 0x%p\n", &a, &b);return *b1 - *a1;
}int compare_char(const void *a, const void *b){//printf("调用compare_char 啦,你好骚气哦! \n");char c1 = *((char *) a);char c2 = *((char *) b);if(c1>='A' && c1<='Z') c1+=32;if(c2>='A' && c2<='Z') c1+=32;return c1 - c2;
}int main(void){int x = 10;int y = 20;//函数有没有地址?//printf("compare_int 的地址: 0x%p \n", &compare_int);//compare_int(&x, &y);//函数指针的定义 把函数声明移过来,把函数名改成 (* 函数指针名)int (*fp)(const void *, const void *);/*贝尔实验室的C和UNIX的开发者采用第1种形式,而伯克利的UNIX推广者却采用第2种形式ANSI C 兼容了两种方式*/fp = &compare_int; //(*fp)(&x, &y); //第1种,按普通指针解引的放式进行调用,(*fp) 等同于compare_intfp(&x, &y); //第2种 直接调用//qsort 对整形数组排序int arr[]={2, 10, 30, 1, 11, 8, 7, 111, 520};qsort(arr, sizeof(arr)/sizeof(int), sizeof(int), &compare_int);for(int i=0; i<sizeof(arr)/sizeof(int); i++){printf(" %d", arr[i]);}//qsort 可以对任何类型的数组进行排序char arr1[]={"abcdefghiABCDEFGHI"};qsort(arr1, sizeof(arr1)/sizeof(char)-1, sizeof(char), &compare_char);for(int i=0; i<sizeof(arr1)/sizeof(char)-1; i++){printf(" %c", arr1[i]);}system("pause");return 0;
}