-
一、指针的引入
int —— 4位;float —— 4位;double —— 8位;short —— 2位;long —— 8位;
- 为函数修改实参提供支撑;
- 为动态内存管理提供支持;
- 为动态数据结构提供支持;
- 为内存访问提供另一种途径。
二、指针概述
- 内存地址:系统为了内存管理的方便,将内存划分为一个个的内存单元(1个内存单元占1个字节),并为每一个内存单元进行了编号,内存单元的编号称为该内存单元的地址。一般情况下,我们每一个变量都是由多个内存单元构成的,所以每个变量的内存地址,其实就是这个变量对应的第一个内存单元的地址,也叫首地址。
- 变量指针:变量地址称为该变量的指针。变量地址往往是指变量在内存中的第一个内存单元的编号(首地址)。
- 指针变量:存放其他变量地址的变量。
- 指向:指针变量中存放“谁”的地址,就说明该指针变量指向了“谁”。
- * :指针运算符
举例:指针初识
/** * 指针 初识 */ #include <stdio.h> void main() { int i = 3;//定义一个普通/一般变量 int *i_point = &i;//定义一个指针变量,并赋值 //指针变量的数据类型要和存储的地址变量类型一致 printf("直接访问-%d\n",i);// 3 //访问普通变量(直接访问) printf("地址访问-%p\n",i_point);// %p访问地址 //访问指针(地址访问) printf("间接访问-%d\n",*i_point);// 3 //访问指针变量(间接访问) }
三、指针变量的定义
语法:
数据类型 *变量列表;
举例:
int a; //普通变量
int *a,*b; //指针变量
注意:
- 虽然定义指针变量 *a ,是在变量名前加上 * ,但是实际变量名为 a ,而不是 *a ;
- 使用指针变量间接访问内存数据时,指针变量必须要有明确的指向;
- 如果想借助指针变量间接访问指针变量保存的内存地址上的数据,可以使用指针变量前加 * 来间接访问;指针变量前加 * ,也称为对指针变量 解引用 。
int i = 5,*p; p = &i;// 将i的地址赋值给指针变量p printf("%d\n",*p);// 间接访问i的值,也成为解引用p对应地址空间的值
- 指针变量只能指向同类型的变量,借助指针变量访问内存,一次访问的内存大小取决于指针变量的类型;
指针变量在定义同时可以初始化:这一点和普通变量是一样的。
int i = 5; int *p = &i;//定义的同时初始化
四、指针变量的使用
-
指针变量的赋值:
//方式1: int a,*p; p = &a;// 指针变量的值是其他变量的地址 //方式2: int a,*p,*q = &a; p = q;//p,q都是a的地址
-
操作指针变量的值:
int a,*p,*q = &a; p = q; printf("%p",q);//%p访问地址 此时返回的是变量a的地址空间
-
操作指针变量指向的值:
int a = 6,*q = &a; printf("%d",*q);// 6 打印输出的是数据
1、两个有关运算符的使用
-
&:取地址运算符。&a是变量a的地址;
-
* :指针运算符(“间接访问”运算符)。*p是指针变量 p 指向的对象的值。
举例:
/* * */ #include <stdio.h> void main() { int a,b; int *pointer_1,*pointer_2; a = 100;b = 10; pointer_1 = &a; pointer_2 = &b; printf("a = %d,b = %d\n",a,b); printf("pointer_1 = %d,pointer_2 = %d\n",*pointer_1,*pointer_2); }
思考题:
举例:声明a,b两个一般变量,使用间接存储的方式进行数据的交换?
/** * 需求:声明a,b两个一般变量,使用间接存取的方式实现数据的交换? */ #include <stdio.h> void main() { // 声明5个变量 int a = 3,b = 5,*p_a=&a,*p_b=&b,*p_t; // 交换前输出 printf("%d,%d\n",*p_a,*p_b); // 交换位置 p_t = p_a; p_a = p_b; p_b = p_t; // 交换后输出 printf("%d,%d\n",*p_a,*p_b); }
举例:指针变量应用。输入a、b两个整数,按先大后小的顺序输出a和b。
/* 需求:指针变量应用。输入a、b两个整数,按先大后小的顺序输出a和b。 */ #include <stdio.h> void main() { int a = 3,b = 5,*p_a = &a,*p_b = &b,*p_t; if( a < b) { p_t = p_a;// 操作指针变量,不会影响到数据本身 p_a = p_b; p_b = p_t; } printf("按从大到小输出a,b的值:%d > %d\n",*p_a,*p_b); }
五、指针变量做函数参数
指针变量做函数参数往往传递的是变量的地址(首地址),借助于指针变量间接访问是可以修改实参变量数据的。
举例:
需求:要求用函数处理,用指针变量做函数的参数。
方式1:交换指向(指向的普通变量的值不变)
#include <stdio.h> /* 需求:指针变量应用。输入a、b两个整数,按先大后小的顺序输出a和b。 */ /* 自定义函数,实现两个数的比较 */ void swap(int *p_a,int *p_b) { int *p_t; // 这种写法,只会改变指向,不会改变地址对应空间的数据 p_t = p_a; p_a = p_b; p_b = p_t; printf("%d > %d\n",*p_a,*p_b); // 5 > 3 } void main() { int a = 3,b = 5; if(a < b) swap(&a,&b); // int *p_a = &a,int *p_b = &b printf("%d > %d\n",a,b);// 3 > 5 }
方式2:交换值(指向的普通变量的值改变)
#include <stdio.h> /* 需求:指针变量应用。输入a、b两个整数,按先大后小的顺序输出a和b。 */ /* 自定义函数,实现两个数的比较 */ void swap(int *p_a,int *p_b) { int t; // 这种写法,只会改变指向,不会改变地址对应空间的数据 t = *p_a; *p_a = *p_b; *p_b = t; printf("%d > %d\n",*p_a,*p_b); // 5 > 3 } void main() { int a = 3,b = 5; if(a < b) swap(&a,&b); // int *p_a = &a,int *p_b = &b printf("%d > %d\n",a,b);// 5 > 3 }
六、通过指针引用数组
1、数组元素的指针
-
数组指针:数组中的第一个元素的地址,也就是数组的首地址;
-
指针数组:用来存放数组元素地址的数组,称之为指针数组。
//定义一个一般数组
int a[] = {1,4,9};
//使用指针变量存储数组的第一个元素的首地址,也就是数组的首地址
int *p = &a[0];//数组首地址
//在C语言中,由于数组名代表数组的首地址,因此,数组名实际上也是指针
int *p = a;
//意味着:int *p = &a[0] 完全等价于 int *p = a;
printf("%d\n",*p);// 1
注意:
虽然我们定义了一个指针变量接收了数组地址,但不能理解为指针变量指向了数组,而应该理解为指向了数组的元素。
2、指针的运算
指针运算:指针变量必须要指向数组中的某个元素。
指针运算的说明 | ||
---|---|---|
序号 | 指针运算 | 说明 |
1 | 自增:p++、++p、p = p+1 | p+=1 | 让指针变量指向下一个元素 |
2 | 自减:p--、--p、p = p-1 | p-=1 | 让指针变量指向上一个元素 |
3 | 加一个数:p+1 | 下一个元素的(首)地址 |
4 | 减一个数:p-1 | 上一个元素的(首)地址 |
5 | 指针相减:p1-p2 | p1、p2之间相差几个元素 |
6 | 指针比较:p1<p2 | 前面的指针小于后面的指针 (操作系统在分配时按从小到大的顺序分配) |
举例:元素个数
#include <stdio.h> int main() { // 一般数组 int a[] = {1,3,5,7,9}; // 计算数组中元素的个数 // sizeof用法:sizeof(运算数) 或者 sizeof 运算数 int len = sizeof a / sizeof a[0]; // 创建指针变量 int *p = a; // 创建循环变量 register int i = 0; // 遍历 for(;i < len; i++) { printf("[1] %d ",a[i]); // 下标法 printf("[2] %d ",*(a+i));// 指针法,但是这种写法,需要注意,a+i无法修改数组,只读 printf("[3] %d ",*(p+i));// 指针法,这种更为灵活,可读可写,建议这种写法p++; // printf("%d\n",*p); // 等价于上面写法 // p++; } printf("\n"); return 0; }
举例:元素个数
#include <stdio.h> int main() { int a[] = {10,22,33,44,55,66,77,88}; int *p = a;// 等价于 int *p = &a[0] 元素:10 p++;// 指针+1,元素值不改变 元素:22 printf("%d\n",*p);// p = p + 1 元素:22 int x = *p++;// x = 22,p++ -- *p:33 printf("%d,%d\n",x,*p);// *p++:先*p,在p++, 元素:22,33 int y = *(++p);// ++p, y = 44; printf("%d,%d\n",y,*p); // *(++p):先p++,再*p,元素:44,44 (*p)++;// 元素值+1,指针不改变 printf("%d\n",*p);// index为3的元素值:44 + 1 = 45 return 0; }
3、数组名做函数参数
表现形式:
void fun(int *p1){}
void main()
{
// 注意:如果实参和形参都是指针,我们的实参需要初始化
int arr[2] = {23,34};
int *p0 = arr;
fun(p0);
}
- 形参和实参都用数组名;
- 实参用数组名,形参用指针变量;
- 实参形参都用指针变量
void fun(int *p1){} void main() { // 注意:如果实参和形参都是指针,我们的实参需要初始化 int arr[2] = {23,34}; int *p0 = arr; fun(p0); }
- 实参为指针变量,形参为数组名
举例:将数组a中n个整数按相反顺序存放
/** * 需求:将数组a中n个整数按相反顺序存放。 */ #include <stdio.h> /* 数组的反转:数组实现*/ void inv(int arr[],int len) { // 反转思路:将第0个和n-1个进行对掉,将第1个和n-2个对掉.. // 定义循环变量i,临时变量temp int i = 0,temp; // 遍历数组 for(;i < len/2;i++) { // 交换 temp = arr[i]; arr[i] = arr[len-1-i]; arr[len-1-i] = temp; } } /* 数组的反转:指针实现 关键字:const 给变量的数据类型前面添加const,代表这个变量是只读变量,无法对此作出修改 */ void inv2(int *arr,const int len) { // 反转思路:将第0个和n-1个进行对掉,将第1个和n-2个对掉.. // 定义循环变量i,临时变量temp *j = &arr[len -1] 等价于 arr + len -1 int *i = arr,*j = &arr[len-1],temp; // 遍历数组 for(;i < j;i++,j--) { // 交换 temp = *i; *i = *j; *j = temp; } } int main() { int array[10] = {12,23,45,55,66,77,88,26,34,32}; int len = sizeof(array)/sizeof(int); inv2(array,len); // 测试是否反转 for(int i = 0;i < len;i++) printf("%d,",array[i]); printf("\n"); return 0; }
七、数组指针(先有数组,后有指针)
数组指针:指向一维数组的指针变量。(指向的是一个完整的数组)
数组指针定义:假定该指针变量指向具有N个元素的一维数组,则数组指针变量定义如下:
数据类型 (*数组指针变量名)[N];
一维数组:
int a[N] = {1,2,3};
int (*p)[N] = &a;
举例:指向数组的指针
/** * 数组指针:指向数组的指针 */ #include <stdio.h> int main() { // 一维数组指针 // 先有数组,再有指针 int arr[3] = {100,200,300}; // 获取数组的元素个数 int len = sizeof arr / sizeof arr[0]; // 定义一个数组指针,指向arr数组 // 数组指针的语法:数据类型 (*指针变量名)[容量]; int (*p)[3] = &arr;// 此时p不是指向arr数组的第一个元素,而是指向arr这个数组本身 printf("%p\n",p); // p++; 此时p++会跳出整个数组 // printf("%p\n",p); printf("%d\n",(*p)[2]);// 300 // 遍历 for(int i = 0; i < len; i++) { printf("%d\n",(*p)[i]); } printf("\n"); // int *p = &arr[0] | arr;// 这种写法,代表p指向的不是数组本身,是数组中的第一个元素 }
二维数组:
int a[][N] = {1,3,5,7};
int (*p)[N] = a[0];// &a[0][0]
分析:
int arr[3] = {1,2,3};
int *p = arr;// &arr[0] 首地址:第1个元素的首地址
int (*p)[3] = &arr;
// p = &arr[0];
int arr[][3] = {1,2,3,4,5,6};
int *p = arr[0]; // &arr[0][0] 首地址:第1行第1列元素的首地址
int (*p)[3] = &arr[0];
// p = &arr[0][0]
举例:用指向元素的指针变量输出二维数组元素的值
/** * 数组指针: 用指向元素的指针变量输出二维数组元素的值 */ #include <stdio.h> int main() { // 定义一个普通的二位数组 int a[3][4] = {1,3,5,7,9,11,13,15,17,19,21,23}; int *p = &a[0][0];// 二维数组 等价于 a[0] // 循环遍历 for(;p < a[0]+12;p++) { if((p - a[0]) % 4 == 0) { printf("\n"); } printf("%4d",*p); } printf("\n"); return 0; }
举例:输出二维数组任一行任一列元素的值
/** * 数组指针:输出二维数组任一行任一列元素的值。 此时:我们需要将二维数组看作是一个特殊的一维数组 */ #include <stdio.h> int main() { int a[3][4] = {1,3,5,7,9,11,13,15,17,19,21,23}; int (*p)[4]; // 我们把行使用指针表示 p = &a[0]; // 等价于 p = a int i,j;// 代表我们要显示的数据对应的行号和列号 printf("请输入行号和列号:\n"); scanf("i=%d,j=%d",&i,&j); printf("a[%d][%d]=%d\n",i,j,*(*(p+i)+j)); return 0; }
举例:二维数组指针案例
/** * 二维数组指针案例 */ #include <stdio.h> int main() { // 数组指针:先有数组,再有指针 int arr[][3] = {{100,200,300},{1000,2000,3000},{10,20,30}}; // 创建一个数组指针,指向二维数组 /* int (*p)[3] = &arr; // p[0] -->{100,200,300},p[1] -->{1000,2000,3000},也就是说: p[0] = 元素100的首地址,p[1] = 元素1000的首地址*/ int (*p)[3] = arr; // arr等价于&arr[0],p[0] = 元素100的首地址 // 获取元素100? printf("100-%d\n",(*p)[0]);// arr[0][0] // 获取元素2000? printf("2000-%d,%d,%d\n",*(*(p+1)+1),*(p[1]+1),p[1][1]);// arr[i][j] ===> *(*(p+i)+j) ===> *(p[i]+j) ===> p[i][j] return 0; }
- 指针和数组中符号优先级: () > [] > *
八、指针数组
-
概念:指针数组是一个数组,数组中的每个元素都是一个指针。
- 特点:
- 先有“指针”,后有“数组”;
- 指针数组的本质是一个数组,只是数组中的元素类型为指针。
- 语法:
数据类型 *数组名[容量];
举例:指针数组
/** * 指针数组 */ #include <stdio.h> int main() { // 定义三个变量 int a = 10, b = 20, c = 30; // 定义指针数组,指针数组用来存放指针(变量或者常量的内存地址) int *arr[3] = {&a,&b,&c}; // 获取数组的大小 int len = sizeof arr / sizeof arr[0]; // 遍历数组 for(int i = 0; i < len; i++) { printf("%3d",*(arr[i])); // 输出每个指针所指向的值,需要解引用 } printf("\n"); return 0; }
- 建议:我们一般使用指针数组处理字符串。
九、字符串指针
1、字符串实现
在C语言中,表示一个字符串有以下两种形式:
- 用字符数组存放一个字符串;
- 用字符指针指向一个字符串。
举例:字符串的两种实现方式
/** * 字符串的两种实现方式 */ #include <stdio.h> /* 使用字符数组实现 */ void fun() { // 定义伪字符串 char str[] = "I Love Your!"; printf("%s\n",str); } /* 使用字符指针实现 */ void fun1() { // 定义伪字符串 char *str = "I Love Your!"; printf("%s\n",str); } int main() { fun(); fun1(); return 0; }
注意:字符数组和字符指针变量都能实现字符串的存储与运算。
2、字符数组和字符指针的联系
- 字符数组由元素组成,每个元素中存放一个字符,而字符指针变量中存放的是地址,也能作为函数参数;
- 只能对字符数组中的各个元素赋值,而不能用赋值语句对整个字符数组赋值;
- 字符数组名虽然代表地址,但数组名的值不能改变。因为数组名是常量;
- 对于字符串中字符的存取,可以用下标法,也可以用指针法。
举例:字符数组和字符指针的关系
/** * 字符数组和字符指针的联系 */ #include <stdio.h> int main() { // 使用两种方式定义字符串 char str1[] = "你好,马杰克!"; char *str2 = "您好,马应龙!"; // 测试赋值 // str1 = "你好,龙瑞!"; // 不能对字符数组整体赋值,如果要赋值,请使用string.h中strcpy() str2 = "你好,药可!"; // 打印输出 printf("%s\n%s\n",str1,str2); char a[] = "I love you!"; char *b = "I love you!"; // 使用下标法和指针法访问字符串 printf("%c\n%c\n",a[4],*(b+4));// v v 空格也是占位的 return 0; }
3、字符串指针作为形式参数
-
实参与形参都可以是字符参数;
-
实参用字符数组,形参用字符指针(在函数内部不能对字符串中的字符做修改)
test5(char *arr,int len)
{
arr[2] = 'A'; // 错误,字符串常量一旦创建,就不能被改变
}
main(){
char arr[] = "abc"; // 字符串常量,常量是不可修改的
test(arr,3);
}
-
实参和形参都是指针变量(在函数内部不能对字符串中的字符做修改)
test(char *arr,int len)
{
arr[2] = 'A'; // 错误
}
main()
{
char arr[] = "abc";
char *p = arr;// &arr[0]
test(p,3);
}
-
实参是指针类型,形参是字符数组
注意:
- 字符数组在创建的时候,会在内存中开辟内存空间,内存空间可以存放字符数据;字符指针在创建 的时候,需要依赖于字符数组,字符指针在内存中开辟的内存空间中,存放的是数组元素的内存地 址。字符指针的创建依赖于字符数组,字符数组可以独立存在,而字符指针不能独立存在;
- 字符数组可以初始化,但是不能赋值;字符指针可以初始化,也可以赋值。
// 字符数组 char str1[11] = "I love You!"; str1 = "Home"; // 错误 str1[] = "home"; // 错误 // 字符指针 char *str2 = "I love You!"; str2 = "home";// 正确
举例:字符指针作为函数参数:用函数调用实现字符串,复制以及计算字符串长度。
/** * 字符指针作为函数参数:用函数调用实现字符串,复制以及计算字符串长度。 */ #include <stdio.h> /* 定义一个函数,传递拷贝的字符串,返回字符串长度 */ int str_copy(char *str1,char *str2) { int i = 0; // 循环变量 while(str1[i]!='\0') { // 实现拷贝 str2[i] = str1[i]; i++; } // 拷贝结束之后,一定要给字符串加上结束符号\0 str2[i] = '\0'; return i; } int main() { // 定义两个数组,从键盘录入字符串 char str1[20],str2[20]; printf("请输入一个字符串:\n"); scanf("%s",str1); printf("str1=%s\n",str1); int len = str_copy(str1,str2); printf("str2=%s\n",str2); printf("len=%d\n",len); return 0; }
举例:给定一个字符串,截取start到end之间字符串,含头不含尾
/** * 给定一个字符串,截取start到end之间字符串,含头不含尾 */ #include <stdio.h> /* 字符串截取函数 */ int str_split(char *str,int start,int end,char *temp) { // 定义一个循环变量 int i = 0,k = 0; // 定义一个字符指针,用来接收str中截取到字符串 // 循环遍历每一个字符 while(str[i]!='\0') { if(i>= start && i < end) { temp[k] = str[i]; k++; } i++; } temp[k] = '\0'; // 更新str中的数据 printf("%s\n",temp); return k; } int main() { char *str = "abcdefg"; char temp[100]; int len = str_split(str,2,5,temp); printf("str=%s,len=%d\n",temp,len); return 0; }
十、函数指针与指针函数
1、函数指针
1.定义:函数指针本质是指针,它是函数的指针(定义一个指针变量,变量中存储了函数的地址)。 函数都有一个入口地址,所谓指向函数的指针,就是指向函数的入口地址。这里函数名就代表入口地址。
2.函数指针存在的意义:
- 让函数多了一种调用方式;
- 函数指针作为形参,可以形式调用(回调函数)
3.定义格式:
返回值类型(*变量名)(形式参数列表)
举例:
int (*p) (int a,int b);
4.函数指针的初始化
-
定义同时赋值
// 得先有函数,才能定义这个函数的指针 int fun(int a,int b){..} // 定义函数指针并给它赋值 int (*p) (int a,int b) = fun;// fun不能跟()
-
先定义后赋值
// 得先有函数,才能定义这个函数的指针 float fun(int a,double b,char c){..} // 先定义函数指针 float (*p) (int a,double b,char c); // 赋值 p = fun;
总结:
- 函数指针指向的函数要和函数指针定义的返回值类型,形参列表对应,否则编译报错;
- 函数指针是指针,但不能指针运算,如p++等,没有实际意义;
- 函数指针作为形参,可以形成回调(回调后面讲);
- 函数指针作为形参,函数调用时的实参只能是与之对应的函数名,不能带小括号;
- 函数指针的形参列表中的变量名可以省略。
举例:求a,b两个数的最大值
/** * 函数指针:指向函数的指针变量就是函数指针 需求:求a,b两个数的最大值 */ #include <stdio.h> int max(int a,int b) { if(a > b) { return a; } return b; } int main() { int a = 3,b = 2,c; // 普通函数调用 c = max(a,b); printf("%d,%d两个数中的最大值是:%d\n",a,b,c); // 通过指针变量访问它指向的函数 // 创建指针并初始化 int (*p)(int,int) = max; // 调用函数指针 c = p(a,b); printf("%d,%d两个数中的最大值是:%d\n",a,b,c); // 调用函数指针 c = (*p)(a,b); printf("%d,%d两个数中的最大值是:%d\n",a,b,c); return 0; }
2、指针函数
1.定义:本质是函数,这个函数的返回值类型是指针,这个函数成为指针函数。
2.定义格式:
指针类型 函数名(形参列表)
{
函数体;
return 指针变量;
}
举例:
int *get(int a)
{
int *b = &a;
// return &a; // 编译报警告
return b;
}
注意:
在函数中不要直接返回一个局部变量的地址,因为函数调用完毕后,布局变量会被回收,使得返回的地址就不明确,此时返回的指针就是野指针。
解决方案:
如果非要访问,可以给这个局部变量添加 static ,可以延长它的生命周期,从二避免野指针(尽量少用,因为存在内存泄漏)。
举例:有若干个学生的成绩(每个学生有4门课程),要求在用户输入学生序号以后,能输出该学生的全部成绩。用指针函数来实现
/** * 指针函数:函数的返回值是指针类型 需求:有若干个学生的成绩(每个学生有4门课程),要求在用户输入学生序号以后,能输出该学生的全部成绩。用 指针函数来实现。 */ #include <stdio.h> /* 定义一个函数,传入学生的序号,返回这个学生的所有课程成绩 */ float *search(float (*p)[4],int n) { // 定义一个指针,用来接收查询到的某个学生的所有课程 float *pt; pt = *(p+n); return pt; } int main() { // 准备所有学生的成绩 float score[][4]={{60,70,80,90},{56,66,76,76},{35,68,90,37}}; int i,m; float *p; printf("请输入学生序号(0~2):\n"); scanf("%d",&m); printf("第%d个学生的成绩:\n",m); p = search(score,m);// 函数返回值为行的首地址 // 遍历 for(i = 0; i < 4;i++) printf("%5.2f\t",*(p+i)); printf("\n"); return 0; }
十一、野指针、空指针
1、野指针
1.定义:访问了一个已经销毁或者访问受限的内存区域外的指针,这个指针就被称为野指针。
2.野指针产生的场景:
- 变量未初始化,通过指针访问该变量;
int a; int *p = &a;//p就是野指针 ptf(*p);//访问野指针,但是数据不安全
- 指针变量未初始化
int *p = NULL;//此时的p也是野指针 ptf(*p);
- 指针指向的内存空间被(free函数)回收了——后面讲;
- 指针函数中直接返回了局部变量的地址;
- 指针指向数组以外的地址(下标越界)。
3.如何避免野指针:
- 写代码要养成两个习惯(通过编码规范避免)
- 指针变量要及时初始化,如果暂时没有对应的值,建议赋值为NULL;
- 数组操作(遍历,指针运算)时,注意数组的长度,避免越界;
- 指针指向的内存空间被回收,建议给这个指针变量赋值为NULL;
int *p = (in*)malloc(10);//动态内存分配 free(p);//动态内存释放 p = NULL;// p不指向任何空间
- 指针变量使用之前要检查他的有效性(以后开发中要做非空校验)
int *p = NULL; if(!p)//非空校验 { return -1; }
说明:NULL是空常量,它的值是0,这个NULL一般存放在内存中的0x00000000位置,这个地址只能存放NULL,不能被其他程序修改。
2、空指针
空指针,又被称作悬空指针:当一个指针的值是NULL,这个指针被称为空指针;对空指针访问会运行报错(段错误)
十二、二级指针
1、定义:二级指针,又被称作多重指针,引用一级指针的地址,此时这个指针变量就得定义成二级指针。
int a = 10;
int *p = &a;
int **w = &p;//二级指针
2、定义格式:
数据类型 **变量名 = 指针数组的数组名或者一级指针的地址
//指针数组
int array = {1,2,3};
int *arr = (&array[0],&array[1],&array[2]);//指针数组
//一级指针
int a = 10;
int *p = &a;//一级指针
3、举例:
// 字符型指针数组
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;//正确,二级指针的地址
4、结论
- 二级指针和指针数组是等效的,和二维数组不等效;
- 二维数组和数组指针是等效,和二级指针不等效;
5、二级指针的用法:
- 如果是字符的二级指针,可以像遍历字符串数组一样遍历他;
- 如果是其他的二级指针,就需要解引用两次访问它所指向的数据。
举例:二级指针案例:使用指向指针数据的指针变量
/** * 二级指针案例:使用指向指针数据的指针变量。 */ #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的常规写法:
a. argc:存储了参数的个数;
b. argv:存储了所有参数的字符串形式
-
main函数是系统通过函数指针的回调形式调用的
注意:如果一个函数没有写返回值类型,这个函数的默认返回类型是int
举例:main函数
/** * 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;//编译错误,因为此时这个变量是只读常量,所以不可更改其值
1、常量指针
- 定义:常量的指针,本质是一个指针,指针指向的数据不能改变。
- 定义格式:
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(); }
2、指针常量
- 定义:指针的常量,指针的指向不能改变
- 定义格式:
数据类型* const 变量名;
举例:
int* const p;//指针常量
- 结论:
- 指针常量的指向不能被改变(不能给指针变量重新赋地址值);
- 指针常量指向的数据可以被改变;
- 注意:指针常量在定义时就要赋值;不能先定义后赋值,否则编译报错。
举例:常量指针与指针常量
/** * 常量指针与指针常量 */ #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(); }
3、常量指针常量
- 定义语法:
const 数据类型* const 变量名;
举例:
const int* const p;// 常量指针常量
- 作用:p的指向不能被改动(地址),p指向的数据不能被改动(地址对应内存中存放的数据)
十五、动态内存分配
我们要想实现动态内存分配,就需要学习标准C提供的函数库:
- 函数所属的库文件;
- 函数的原型 - 函数的声明
- 函数名;
- 形参;
- 返回值类型。
- 函数的功能。
注意:内存分配函数在申请内存时,建议用多少申请多少,可以有少量的预留量;但不能越界访问(虽然编译和运行不报错,但数据不安全)
1、常用函数
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
- 形式参数:
1)size_t nitems:申请多少个;
2)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("\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 是错误的)。
十六、扩展:形式参数和实际参数的对应关系
举例:不可以
//形式参数和实际参数的对应关系 #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; }
十七、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*在间接访问(解引用)前要强制类型转换,但不能太随意,否则存和去的数据类型不 一致。
十八、函数的传参
- 值传递:一般发生在函数形参的类型为char、short、int、long、float、double这样的类型,它的传递,一般是实参将自己的值复制一份给形参,也就是实参变量和形参变量的变量空间是分开的。此时形参无法改变实参的数据;
- 引用传递:一般发生在函数形参的类型为数组、指针这样的类型,它的传递,一般是实参将自己的内存首地址复制一份给形参,也就是实参变量和形参变量对应内存空间是同一个。此时形参可以改变实参的数据。
十九、内存操作
我们对于内存的操作借助于 string.h 这个库提供的内存操作函数。
1、内存填充
- 头文件: #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
/** * 内存操作函数-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; }
2、内存拷贝(相当于替换,不是复制)
-
头文件:#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
/** * 内存操作函数-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; }
3、内存比较
-
头文件: #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
/** * 内存操作-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(); }
4、内存查找
-
头文件: #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 / memchr
/** * 内存操作-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(); }
二十、作业
1. 利用指针变量将一个数组中的数据反向输出。
代码:
/** * 利用指针变量将一个数组中的数据反向输出; */ #include <stdio.h> void rev(int *arr,const int len) { int *i = arr,*j = &arr[len - 1],t;//定义变量 for(;i < j;i++,j--)//遍历,反向输出,交换数据 { t = *i; *i = *j; *j = t; } } int main() { int i = 0; int arr[3] = {1,2,3};//定义数组中的数据 int len = sizeof(arr) / sizeof(int);//计算长度 for(i = 0;i < len; i++)//遍历,正向输出数组 { printf("您所输入的数组中的数据为:%3d\n",arr[i]); } printf("\n"); rev(arr,len);//引用自定义函数 for(int i = 0;i < len;i++)//遍历,输出反向后的数据 { printf("反向输出的数据为%3d\n",arr[i]); } return 0; }
运行效果:
2. 利用指针变量计算下标为奇数的数组的和;
代码:
/** * 利用指针变量计算下标为奇数的数组的和; */ #include <stdio.h> #include <math.h> int main() { int arr[8] = {11,22,33,44,55,66,77,88};//定义数组 int len = sizeof(arr) / sizeof(int); int (*p)[8] = &arr;//创建指针变量 int sum = 0; int i = 0; for(int i = 0;i < len;i++) { if(i % 2 != 0) { printf("您定义的数组中下标为奇数的数为:%d\n",(*p)[i]); sum += (*p)[i]; } } // printf("您定义的数组中下标为奇数的数为:%d\n",(*p)[i]); printf("您定义的数组中下标为奇数的数组的和为:%d\n",sum); return 0; }
运行效果:
3. 确认整型,字符型,浮点型指针变量的大小;
代码:
/** * 确认整型,字符型,浮点型指针变量的大小; */ #include <stdio.h> int main() { int *intVariable; char *charVariable; float *floatVariable; double *doubleVariable; printf("整型指针变量的大小为:%zu byte\n",sizeof(intVariable)); printf("字符型指针变量的大小为:%zu byte\n",sizeof(charVariable)); printf("单精度浮点型指针变量的大小为:%zu byte\n",sizeof(floatVariable)); printf("双精度浮点型指针变量的大小为:%zu bbyte\n",sizeof(doubleVariable)); return 0; }
运行效果:
4. 利用指针变量输出字符数组中的所有字符。
代码:
/** * 利用指针变量输出字符数组中的所有字符; */ #include <stdio.h> int main() { char arr[11] = "we are one!";//定义数组 int len = sizeof arr / sizeof arr[0];//计算数组中的元素个数 char *p = arr;//创建指针变量 register int i = 0;//创建循环变量 for(;i < len;i++)//遍历 { printf("%c\n",*(p+i)); } printf("\n"); return 0; }
运行效果:
5. 编写一个函数,用指针变量做参数,用于求出一个浮点型数组元素的平均值。
代码:
/** * 编写一个函数,用指针变量做参数,用于求出一个浮点型数组元素的平均值 */ #include <stdio.h> #include <math.h> float calcuAve(float *a,int len) { float sum = 0.0; float aver = 0.0; for(int i = 0;i < len;i++) { sum += *(a+i); } aver = sum / len; return aver; } int main() { float arr[3] = {1.3,5.4,4.8}; int len = sizeof(arr) / sizeof(arr[0]); float sum = 0.0,aver = 0.0; aver = calcuAve(arr,len); printf("您所输入的数组的数据的均值为:aver = %f\n",aver); return 0; }
运行效果:
6. 编写函数,要求用指针做形参,分别实现以下功能:
(1)求一个字符串长度
(2)在一个字符串中统计大写字母的个数
(3)在一个字符串中统计数字字符的个数
代码:
/** * 编写函数,要求用指针做形参,分别实现以下功能: (1)求一个字符串长度 (2)在一个字符串中统计大写字母的个数 (3)在一个字符串中统计数字字符的个数 */ #include <stdio.h> #include <string.h> //定义求字符串长度函数 int fun_long(char *a) { unsigned long lo = strlen(a); printf("您所输入的字符串的长度为:%lu\n",lo); return 0; } //定义求大写字母个数的函数 int fun_findCapsLett(char *a) { int lett = 0;//初始化 while(*a != '\0') { if(*a <= 'Z' && *a >= 'A') { lett++; } a++; } printf("您所输入的字符串中大写字母的个数为:%d\n",lett); return lett; } //定义求数字字符的个数 int fun_findNumbers(char *a) { int num = 0; while(*a != '\0') { if(*a <= '9' && *a >= '0') { num++; } a++; } printf("您所输入的字符串中数字字符的个数为:%d\n",num); return num; } int main() { //定义字符串,输出字符串 char slogan[] = "1 2 3 We Are One!"; printf("您所输入的字符串为:%s\n",slogan); //输出字符串长度 fun_long(slogan); //定义字符串长度 int len = sizeof(slogan) / sizeof(slogan[0]); //输出大写字母个数 fun_findCapsLett(slogan); //输出数字字符个数 fun_findNumbers(slogan); return 0; }
运行效果:
7. 编写函数,要求用指针做形参,实现将二维数组(行列相同)的进行转置(行列数据互换): int(*p) [N]
代码:
/** * 需求:编写函数,要求用指针做形参,实现将二维数组(行列相同)的进行转置(行列数据互换) */ #include <stdio.h> /** * 数组转置 */ void transpose(int rows, int cols, int (*arr)[cols]) { int temp; for (int i = 0; i < rows; i++) { for (int j = i + 1; j < cols; j++) { temp = arr[i][j]; arr[i][j] = arr[j][i]; arr[j][i] = temp; } } } int main() { // 定义一个二位数组 int arr[3][3] = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}}; printf("原数组:\n"); for (int i = 0; i < 3; i++) { for (int j = 0; j < 3; j++) { printf("%d ", arr[i][j]); } printf("\n"); } // 数组转置 transpose(3, 3, arr); printf("转置后的数组:\n"); for (int i = 0; i < 3; i++) { for (int j = 0; j < 3; j++) { printf("%d ", arr[i][j]); } printf("\n"); } return 0; }
运行效果:
8. 编写函数,要求用指针做形参,实现统计二维数组上三角中的0 的数量:
代码:
/** * 编写函数,要求用指针做形参,实现统计二维数组上三角中的0的数量 */ #include <stdio.h> int statistics(int *arr,int rows,int cols) { int num = 0; for(int i = 0;i < rows;i++) { for(int j = i;j < cols;j++) { if(*(arr + i * cols + j) == 0) { num++; } } } return num; } int main() { //定义一个二维数组 int arr[3][3] = {{1,2,0},{4,0,6},{7,8,0}}; int num = 0; printf("原数组:\n"); for(int i = 0;i < 3;i++)\ { for(int j = 0;j < 3;j++) { printf("%d",arr[i][j]); } printf("\n"); } int i,j; //统计上三角中0的个数 num = statistics(&arr[0][0],3,3); printf("二维数组中上三角中的0的数量为:%d\n",num); return 0; }
运行效果:
9. 编写一个指针函数,返回二维数组中最大元素的地址。
代码:
/** * 编写一个指针函数,返回二维数组中最大元素的地址 */ #include <stdio.h> //#include <string> int* address(int arr[][3],int rows,int cols) { // int max = &arr[0][0]; int *max = &arr[0][0]; for(int i = 0;i < rows;i++) { for(int j = 0;j < cols;j++) { if(arr[i][j] > *max) { max = &arr[i][j]; } } } return max; } int main() { //定义一个二维数组 int arr[3][3] = {{1,2,3},{4,5,6},{7,8,9}}; // int max = 0; printf("定义的二维数组为:\n"); for(int i = 0;i < 3;i++) { for(int j = 0;j < 3;j++) { printf("%3d",arr[i][j]); } printf("\n"); } int i,j; int *max = address(arr,3,3); // printf("二维数组中最大元素 %d 的地址为:(%d,%d)\n",*max,(max - &arr[0][0])/3,(max-&arr[0][0])%3); printf("二维数组中最大元素 %d 的地址为 %p \n",*max,max); return 0; }
运行效果:
10. 面试题
1)定义整形变量i; int i;
2)p为指向整形变量的指针变量; int *p;
3)定义整形一维数组p,它有n 个整形元素; int p[n];
4)定义一维指针数组p,它有n个指向整形变量的指针元素; int p[n]; 5)定义p为指向(含有n个整形元素的一维数组)的指针变量;int(p)[n];
6)p为返回整形函数值的函数; int p();
7)p为返回一个指针的函数,该指针指向整形数据; int* p();
8)p为指向函数的指针变量,该函数返回一个整形值; int(*p)();
9)p是一个指向整形指针变量的指针变量; int **p;
11. 动态申请一个具有10个float类型元素的内存空间,从一个已有的数组中拷贝数据,并找出第一次出 现 12.35 的下标位置,并输出。
代码:
/** * 动态申请一个具有10个float类型元素的内存空间,从一个已有的数组中拷贝数据,并找>出第一次出现 12.35 的下标位置,并输出。 */ #include <stdio.h> #include <stdlib.h> #include <string.h> void test1() { //在堆内存申请了一块存储空间 // int *p = (int*)malloc(10 * sizeof(float));//动态申请一个具有10个float类型>元素的内存空间 // if(!p) // { // puts("内存分配失败!"); // return;//后续代码不需要执行 // } float p1[10] = {12.2,32.5,34.6,76.5,65,43,12.35,65,87,88}; float p2[10] = {0}; memmove(p2,p1,10*sizeof(float)); //测试输出数组 for(int i = 0;i < 10;i++) printf(" %4.2f ",p1[i]); printf("\n"); printf("\n"); for(int j = 0;j < 10;j++) { printf(" %4.2f ",p2[j]); printf("\n"); if(p2[j] == 12.35) printf("%d\n",j); } } int main() { test1(); return 0; }
运行效果:
12. 动态申请一个整型数组,并给每个元素赋值,要求删除第3个元素;
代码:
运行效果:
13. 动态申请一个整型数组,并给每个元素赋值,要求在第4个元素后插入100;
代码:
运行效果:
14. 附加题【选做】: 编写一个函数,实现 memmove 的功能。
代码:
运行效果: