文章目录
指针(下)
野指针、空指针
野指针
-
定义:访问了一个已经销毁或者访问受限的内存区域外的指针,这个指针就被称为野指针。
-
野指针产生的场景:
-
变量未初始化,通过指针访问该变量
int a; int *p = &a; // p就是野指针 ptf(*p); // 访问野指针,但是数据不安全
-
指针变量未初始化
int *p = NULL; // 此时的p也是野指针 ptf(*p);
-
指针指向的内存空间被(free函数)回收了—后面讲
-
指针函数中直接返回了局部变量的地址。
-
指针指向数组以外的地址(下标越界)
-
-
何避免野指针:
写代码要养成两个习惯(通过编码规范避免)
- 指针变量幻及时初始化,如果暂时没有对应的值,建议赋值为NULL;
- 数组操作(遍历,指针运算)时,注意数组的长度,避免越界
- 指针指向的内存空间被回收,建议给这个指针变量赋值为NULL;
int *p = (int*)malloc(10);// 动态内存分配
free(p);// 动态内存释放
p = NULL;// p不指向任何空间
-
指针变量使用之前要检查它的有效性(以后开发中要做非空校验)
int *p = NULL; if(!p) { return -1; }
说明:NULL是空常量,它的值是0,这个NULL一般存放在内存中的0x00000000位置,这个地址只能存放NULL,不能被其他程序修改。
空指针
空指针,又被称作悬空指针:当一个指针的值是NULL,这个指针被称为空指针;对空指针访问会运行报错(段错误)
二级指针
- 定义:二级指针,又被称作多重指针,引用一级指针的地址,此时这个指针变量就得定义成二级指针。
int a = 10;
int *p = &a;
int **w = &p;
- 定义格式
数据类型 **变量名 = 指针数组的数组名或者一级指针的地址
// 指针数组
int array = {1,2,3};
int *arr = {&array[0],&array[1],&array[2]};// 指针数组
// 一级指针
int a = 10;
int *p = &a; // 一级指针
- 举例:
// 字符型指针数组
char *arr[3] = {"abc","aaa034","12a12"};// 等效于:char arr[3][6] = {"abc","aaa034","12a12"}
// 定义二级指针并赋值(指针需要跟依赖的源同类型)
char **p = arr;// 正确
int array[2][3] = {{1,2,3},{11,22,33}};
int **k = array;// 编译报错,数据类型不相符(二维数组不等于指针数组)
int a = 90;
int *p = &a;// 一级指针
int **k = &p;// 正确,二级指针
- 结论
- 二级指针和指针数组是等效,和二维数组不等效
- 二维数组和数组指针是等效,和二级指针不等效
- 二级指针的用法:
- 如果是字符的二级指针,可以像遍历字符串数组一样遍历它
- 如果是其他的二级指针,就需要解引用两次访问它所指向的数据
案例:
/**
* 二级指针案例:使用指向指针数据的指针变量。
*/
#include <stdio.h>
void fun1()
{
char *name[]={"Follow me","BASIC","Great Wall","FORTRAN","Computer design"};
// 定义一个二级指针
char **p;
// 定义循环变量
int i = 0;
// 遍历指针数组
do
{
p = name + i;
printf("%s\n",*p);
i++;
}while(i < 5);
printf("\n");
}
void fun2()
{
int arr1[5] = {11,12,13,14,15};
// 创建一个指针数组
int *arr[] = {&arr1[0],&arr1[1],&arr1[2],&arr1[3],&arr1[4]};
int **p = arr,i = 0;
// 遍历
for(;i < 5; i++)
{
// printf("%5d",**(p+i));
printf("%5d",**p);
p++;
}
printf("\n");
}
int main()
{
fun1();
fun2();
}
main函数的原型
定义:main函数有多种定义格式,main函数也是函数,函数相关的结论对main函数也有效(也可以定义main函数的函数指针)。
main函数的完整写法:
int main(int argc,char *argv[]){}
int main(int argc,char **argv){}
扩展写法:
int main(){}
int main(void){}
void main(){}
main(){} ---- int main(){}
void main(void){}
int main(int a){}
int main(int a,int b,int c){}
...
说明
-
argc,argv是形参的名称,它们俩可以修改
-
main函数的扩展写法有些编译器不支持,编译报警告
-
argc和argv的常规写法:
-
argc:存储了参数的个数
-
argv:存储了所有参数的字符串形式
-
-
main函数是系统通过函数指针的回调形式调用的
注意:如果一个函数没有写返回值类型,这个函数的默认返回类型是int。
案例:
/**
* main函数
*/
#include "stdio.h"
int main(int argc,char **argv)
{
int k;
for (k=1;k < argc;k++)
printf("%s\n",argv[k]);
}
常量指针与指针常量
常量:分为字面量和只读常量,字面量(就是我们平时直接操作的如:
printf(12)|printf(“hello”));只读常量使用关键字 const 修饰,凡是被这个关键字修饰的变量,一旦赋值,值就不能改变。
语法:
// 字面量举例,字面量是一种匿名的常量
printf(12);
printf("请输入一个数:\n");
// 只读常量
const int a = 10;
a = 21;// 编译错误,因为此时这个变量是只读常量,所以不可更改其值
常量指针
定义:常量的指针,本质是一个指针,指针指向的数据不能改变。
-
定义格式:
const 数据类型 *变量名;
举例:
const int *p; // p就是常量指针
-
结论
-
常量指针指向的数据不能被改变(不能解引用间接修改数据)
-
常量指针的地址可以改变。
-
-
应用场景:作为形式参数,实际参数需要给一个常量。
-
案例:
#include <stdio.h>
/* 常量指针 */
void test1()
{
// 定义变量
int a = 10;
// 定义常量指针
const int *p = &a;
// *p = 100; // 编译报错,常量的值不能修改(常量指针指向地址空间的数值不能修改)
printf("%d\n",*p);// 10
int b = 90;
p = &b; // 编译通过,常量的地址可以修改(常量指针指向的地址空间可以发生改变)
printf("%d\n",*p);// 90
}
int main()
{
test1();
}
指针常量
-
定义:指针的常量,指针的指向不能改变
-
定义格式
数据类型* const 变量名;
举例:
int* const p; // 指针常量 1
-
结论:
-
指针常量的指向不能被改变(不能给指针变量重新赋地址值)
-
指针常量指向的数据可以改变。
-
-
注意:指针常量在定义时就要赋值;不能先定义后赋值,否则编译报错。
-
案例:
/** * 常量指针与指针常量 */ #include <stdio.h> /* 指针常量 */ void test2() { // 定义变量 int a = 10; // 定义指针变量 int* const p = &a; // 错误写法:先定义,后赋值(编译报错) // int* const p; // p = &a; // 间接取数据 pirntf("%d\n",*p); // int b = 200; // p = &b;// 编译报错,地址不能改变 *p = 200; printf("%d\n",*p);// 200 } int main() { test2(); }
常量指针常量
-
定义语法:
const 数据类型* const 变量名;
-
举例:
const int* const p; // 常量指针常量
- 作用:p的指向不能被改动(地址),p指向的数据不能被改(地址对应内存中存放的数据)
动态内存分配
我们要想实现动态内存分配,就需要学习标准C提供的函数库:
- 函数所属的库文件
- 函数的原型-函数的声明
- 函数名
- 形参
- 返回值类型
- 函数的功能
注意:内存分配函数在申请内存时,建议用多少申请多少,可以有少量的预留量;但不能越界访问(虽然编译和运行不报错,但数据不安全)
常用函数
malloc
-
头文件: #include <stdlib.h>
-
函数功能:C 库函数 void *malloc(size_t size) 分配所需的内存空间,并返回一个指向它的指针。
-
函数原型:
-
函数名:malloc
-
形式参数:size_t size:内存块的大小,以字节为单位。本质上就是一个 unsigned int
-
返回值类型:void* :该函数返回一个指针,指向已分配大小的内存,如果请求失败,返回NULL。
-
-
举例:
int *p = (int*)malloc(4);
-
说明:
- malloc函数分配的内存没有默认值,是不确定数,大概率是0;
- malloc函数申请的内存空间连续。
calloc
- 头文件: #include <stdlib.h>
- 函数功能:C库函数 void * calloc(size_t nitems,size_t size) 分配所需的内存空间,并返回一个指向它的指针。
malloc和calloc之间不同点事,malloc不会设置内存为零,而calloc会设置内存为零。
-
函数原型: void *calloc(size_t nitems,size_t size)
-
函数名:calloc
-
形式参数:
- size_t nitems:申请多少个
- size_t size:一个占几个内存单元(一个内存单元 等于 一个字节)
-
返回值类型:void*:该函数返回一个指针,指向已分配大小的内存。如果请求失败,返回NULL。
-
举例:
int *p = (int*)calloc(3,4); // p指向的空间的大小是12个字节 if(!p) printf("内存申请失败!\n");
-
说明:
- calloc函数分配的内存有默认值,每个内存单元都是0
- calloc函数申请的内存空间连续
- calloc大多时候为数组中的元素申请内存
转存栈中数组中的数据:
int arr[3] = {10,20,30}; // 在栈区 int *p = (int*)calloc(3,4); // 申请内存,在堆区 if(!p) puts("内存申请失败!"); // 转存 for(int i = 0;i < 3; i++) p[i] = arr[i]; // 遍历 for(int i = 0;i < 3; i++) printf("%d,",p[i]); printf("\n"); // p使用完,记得释放内存 free(p); p = NULL; // 内存回收后,建议置空
realloc
-
头文件: #include <stdlib.h>
-
函数功能:尝试重新调整之前调用malloc或calloc所分配的ptr所指向的内存块的大小。
-
函数原型: void *realloc(void *ptr,size_t size)
-
函数名:realloc
-
形式参数:
- void *ptr:是malloc或者calloc的返回值
- size_t size:重新分配后的内存大小
-
返回值:void*:该函数返回一个指针,指向已分配大小的内存。如果请求失败,返回NULL。
-
案例
int *p = (int*)malloc(4); int *w = (int*)realloc(p,20); // int *q = (int*)realloc(p,0); // 等效于free(p)
说明:
-
realloc以原来malloc返回的内存地址开始,分配总共20个字节的内存空间
-
如果原来的内存空间后有20个连续空间,就扩容20-4 =16个内存单元,返回原来旧的内存首地址。
-
如果原来的内存空间后不够20个连续内存空间,就重新找一个内存地址开始,申请20个内存单元。并将原来的数据拷贝到新的内存中,回收旧的内存单元,并返回新的内存首地址。
-
free
-
头文件: #include <stdlib.h>
-
函数功能:释放之前调用 malloc、calloc、realloc所分配的内存空间,是访问完记得使用NULL置空。
-
函数原型: void free(void *ptr)
- 函数名:free
-
形式参数:
- void *ptr:calloc,malloc.realloc的返回值
-
返回值类型:void:没有返回值
-
注意:
-
堆内存中的指针才需要回收,栈中系统会自动回收
-
堆内存不能重复回收,运行会报错
-
说明:
- 堆的内存空间相比较栈要大很多
- 内存分配函数返回的指针变量可以参与运算(只读),但不能被修改(p++或者p+=i 是错误的)
void与void*的区别
-
定义:
- void:是空类型,是数据类型的一种
- void*:是指针类型,是指针类型的一种,可以匹配任意类型的指针,类似于通配符
-
void
-
说明:void作为返回值类型使用,表示没有返回值;作为形参,表示形参列表为空,在调用函数是不能给实参
-
举例
// 函数声明 void fun(void); // 等效于 void fun(); // 函数调用 fun();
-
-
void*
-
说明:
-
void*是一个指针类型,但该指针的数据类型不明确,无法通过解引用获取 内存中的数据,因为 void* 不知道访问几个内存单元。
-
void*是一种数据类型,可以作为函数返回值类型,也可以作为形参类型
-
void*类型的变量在使用之前必须强制类型转换,明确它能够访问几个字节的内存空间
int *p = (int*)malloc(4); double *p2 = (double*)malloc(8);
举例:
#include <stdio.h> #include <stdlib.h> // 函数定义 void* fun(void* p) // 指针函数(返回值类型是指针的函数,此时返回的是不明确类型,需要外部强转) { int *p; // double *p; // long *p; // char *p; return p; } // 函数调用 void main() { int *p; void* a = fun(p);// 这种接收方式,实际上没有意义 printf("%p\n",a);// 可以正常打印,打印出一个地址 *a = 10;// 编译报错,void*变量不能解引用访问数据 int *w = (int*)a; *w = 10;// 编译和运行正常,void*变量a在使用前已经强制类型转换了,数据类型明确了,访问的内存单元明确了。 }
-
说明:
- void作为返回值类型:这个函数可以返回任意类型( char,int*,double*等 )的指针。
- void作为形参类型:这个函数在调用时,可以给任意类型( char,int*,double*等 )的指针。
-
总结:
- void* 类似于通配符,不能对void*类型的变量解引用(因为不明确内存单元的大小)。
- void*在间接访问(解引用)前要强制类型转换,但不能太随意,否则存和去的数据类型不一致。
-
-
内存操作
我们对于内存的操作借助于 string.h 这个库提供的内存操作函数。
内存填充
-
头文件: #include <string.h>
-
函数原型: void *memset(void *s,int c,size_t n);
-
函数功能:填充s开始的堆内存空间前n个字节,使得每个字节值为c。
-
函数参数:
- void *s:待操作内存首地址。
- int c:填充的字节数据。
- size_t n:填充的字节数。
-
返回值:返回s
-
注意:c常常设置为0,用于动态内存初始化
-
案例:
/** * 内存操作函数-memset */ #include <stdio.h> #include <stdlib.h> #include <string.h> void test1() { // 在堆内存申请了一块存储空间 int *p = (int*)malloc(4 * sizeof(int)); if(!p) { puts("内存分配失败!"); return;// 后续代码不需要执行 } // 给这块内存进行初始化操作(填充) memset(p,0, 4 * sizeof(int)); printf("%d\n",*(p+1)); // 内存使用完毕,进行回收 free(p); p = NULL; } int main() { test1(); return 0; }
内存拷贝
-
头文件: #include <string.h>
-
函数原型: void *memcpy(void *dest,const void *src,size_t n); 适合目标地址与源地址内存无重叠的情况。
-
void *memmove(void *dest,const void *src,size_t n);
-
函数功能:拷贝src开始的堆内存空间前n个字节,到dest对应的内存中。
-
函数参数:
- void *dest:目标内存首地址。
- void *src:源内存首地址。
- size_t n:拷贝的字节数。
-
返回值:返回dest
-
注意:
-
内存申请了几个内存空间,就访问几个内存空间,否则数据不安全
-
memcpy与memmove一般情况下是一样的,更建议使用memmove进行内存拷贝;
因为memmove函数是从自适应(从后往前或者从前往后)拷贝,当被拷贝的内存和目的地的内存有重叠时,数据不会出现拷贝错误。而memcpy函数是从前往后拷贝,当被拷贝的内存和目的地内存有重叠时,数据会出现拷贝错误。
-
-
案例:
/** * 内存操作函数-memcpy|memmove */ #include <stdio.h> #include <stdlib.h> #include <string.h> void test1() { // 申请内存 // int *p1 = (int*)malloc(4 * sizeof(int)); // int *p2 = (int*)malloc(6 * sizeof(int)); // 给p1,p2填充数据,可以使用for循环.. // for(int i = 0; i < 4; i++) // p1[i] = 10 + i; // memset(p2,0,6 * sizeof(int)); // 创建数组 int p1[4] = {11,12,13,14}; int p2[6] = {21,22,23,24,25,26}; // 将p1中的数据通过内存拷贝函数,拷贝到p2 // memcpy(p2+2,p1+1,2*sizeof(int)) // int p2[6] = {21,22,12,13,25,26} memmove(p2+2,p1+1,2*sizeof(int)); // 测试输出数组 for(int i = 0; i < 4; i++) printf("%4d",p1[i]); printf("\n"); for(int j = 0; j < 6; j++) printf("%4d",p2[j]); printf("\n"); // 如果使用手动分配的指针,一定要记得释放内存 // free(p1); // free(p2); // p1 = NULL; // p2 = NULL; } int main() { test1(); return 0; }
内存比较
-
头文件: #include <string.h>
-
函数原型: int memcmp(void *dest,const void *src,size_t n)
-
函数功能:比较src和dest所代表的内存前n个字节的数据;
-
函数参数:
- void *dest:目标内存首地址
- const void* src:源内存首地址
- size_t n:比较的字节数
-
返回值:
-
0 :数据相同
-
>0 :dest中的数据大于src
-
<0 :dest中的数据小于src
-
-
注意:n一般和src,dest的总容量一样;如果不一样,内促比较的结果就不确定了。
-
案例:
/** * 内存操作-memcmp */ #include <stdio.h> #include <stdlib.h> #include <string.h> void test1() { // 申请内存 int *p1 = (int*)malloc(3*sizeof(int)); int *p2 = (int*)malloc(4*sizeof(int)); // int p1[4] = {1,0,3,6}; // int p2[4] = {1,2,3,4}; // int result = memcmp(p1,p2,4*sizeof(int)); *p1 = 65; *p2 = 70; char *a = (char*)p1;// 类型转换 char *b = (char*)p2; printf("%c,%c\n",*a,*b); int result = memcmp(a+1,b+1,1*sizeof(char)); printf("%d\n",result); } int main() { test1(); }
内存查找
- 头文件: #include <string.h>
- 函数原型: int *memchr|*memrchr(const void *s,int c,size_t n)
- 函数功能:在s开始的堆内存空间前n个字节中查找字节数据c
- 函数参数:
- const void *s:待操作内存首地址;
- int c:待查找的字节数据
- size_t n:查找的字节数
- 返回值:返回查找到的字节数据地址
- 注意:如果内存中没有重复数据,memchr和memrchr结果是一样的;如果内存中有重复数据,memchr和memrchr结果就不一样;
举例:
void *memrchr(..);// 在使用时编译会报错,需要使用外部声明
// 外部申请
extern void *memrchr(..);
-
案例:
/** * 内存操作-memchr | memrchr */ #include <stdio.h> #include <stdlib.h> #include <string.h> // 声明外部函数 extern void *memrchr(const void *s,int c,size_t n); void test1() { // 申请内存 int *p = (int*)malloc(4*sizeof(int)); if(!p) { puts("内存分配失败!"); return; } // 给变量赋值 for(int i = 0; i < 4; i++) { p[i] = i * 2; } p[3] = 4; // 输出 for(int i = 0; i < 4; i++) { printf("%d,",p[i]); } printf("\n"); // 内存查找 memchr int *x = (int*)memchr(p,4,4*sizeof(int)); printf("%p--%p--%d\n",x,p,*x); // 内存查找 memrchr int *y = (int*)memrchr(p,4,4*sizeof(int)); printf("%p--%p--%d\n",y,p,*y); // 回收内存 free(p); p = NULL; } int main() { test1(); }
扩展:形式参数和实际参数的对应关系
//形式参数和实际参数的对应关系
#include <stdio.h>
//void test(int arr[]) //可以
//void test(int arr[2]) //可以
//void test(int * arr) //可以
//void test(int *arr[]) //不可以,编译报错
//void test(int ** arr) //不可以
//void test(int (*arr)[]) //不可以
//---------------------------------
//void test2(int * arr[]) //可以
//void test2(int ** arr) //可以
void test2(int (*arr)[]) //不可以
{
printf("test执行了\n");
}
int main()
{
/*
int arr[3]={0};
test(arr);
*/
int *arr[3] = {0};
test2(arr);
return 0;
}
//形式参数和实际参数的对应关系
#include <stdio.h>
//void test(int arr[2][3]) //可以
//void test(int arr[][3]) //可以
//void test(int arr[2][]) //不可以
//void test(int arr[][]) //不可以
//void test(int (*arr)[]) //可以
//void test(int(*)arr[]) //语法错误
//void test(int(*arr)[3])
//void test(int *arr[]) //不可以
//----------------------------------------
//void test2(int *arr[]) //可以
//void test2(int arr[][1]) //不可以
//void test2(int **arr) //可以
void test2(int(*arr)[]) //不可以
{
printf("test\n");
}
int main()
{
/*
int arr[2][3] = {0};
test(arr);
*/
/*
int a = 20;
int *arr[] = {&a};
test2(arr);
*/
int** p;
test3(p);
return 0;
}