回顾: enum 枚举 union 联合(共用) 请谈一谈 结构体和联合的区别 指针高级 二级指针 修改函数外面 指针变量 字符串数组 操作
------------------------------
void * 空指针 没有类型的指针
任何类型的指针可以赋值给空指针,无需类型转换
在使用空指针时,需要将空指针转换为具体的类型
#include <stdio.h> int main(){ void *pv = NULL; //空指针 char c = 'A'; int i= 0x31323334; //1234 char *pc=NULL; pc= &c; pc= (char *)&i; pv = &c;// printf("*pv = %c ",*(char *)pv);//A 在使用空指针时,需要将空指针转换为具体的类型 printf("*pc = %c ",*pc);//4 高位到低位输出字符串 printf("*pc = %c ",*(pc+1));//3 printf("*pc = %c ",*(pc+2));//2 printf("*pc = %c ",*(pc+3));//1 getchar(); return 0; }
空指针的使用
1. 函数形式参数的类型
/* * 空指针的使用 */ #include <stdio.h> //可以对任意类型的变量进行输出 void myprint( void *pv,int type) { if(type == 1) { printf("*pv = %d ",*(int *)pv); } if(type == 2) { printf("*pv = %c ",*(char *)pv); } if(type == 3) { printf("*pv = %lf ",*(double *)pv); } } int main(){ int i = 20; char c = 'C'; double d = 3.14; #if 0 printf("i = %d ",i); printf("c = %c ",c); printf("d = %lf ",d); #endif myprint(&i,1); myprint(&c,2); myprint(&d,3); getchar(); return 0; }
2. 动态内存申请到的内存,返回指向该内存区域的void * 指针
函数指针
/*
* 函数指针
/
#include <stdio.h> int add(int a,int b){ return a+b; } int main(){ printf("add 函数的地址:%p ",&add); //?? printf("main 函数的地址:%p ",&main); //?? getchar(); }
add 函数的地址:00007FF7535B1000
main 函数的地址:00007FF7535B1010
1. 函数都是有地址,函数名即代表内存地址
#include <stdio.h> int add(int a,int b){ return a+b; } int main(){ printf("add 函数的地址:%p ",add); //?? printf("main 函数的地址:%p ",main); //?? getchar(); }
add 函数的地址:00007FF615181000
main 函数的地址:00007FF615181010
int (*fptr)(int,int); //声明了一个函数指针变量
//指针变量名 fptr,该函数指针 返回一个int 传入 两个int的类型
#include <stdio.h> int add(int a,int b){ return a+b; } int (*fptr)(int,int); int main(){ fptr = add; //将函数add 的地址 赋值给函数指针变量 printf("*fptr = %p ",*fptr); printf("add 函数的地址:%p ",add); //?? printf("main 函数的地址:%p ",main); //?? getchar(); } *fptr = 00007FF67D581000 add 函数的地址:00007FF67D581000 main 函数的地址:00007FF67D581010
2. 能否声明一个变量保存函数的地址,保存函数的地址的变量就是函数指针变量,即函数指针
//通过 函数指针变量 调用函数
#include <stdio.h> int add(int a,int b){ return a+b; } int (*fptr)(int,int); int main(){ fptr = add; //将函数add 的地址 赋值给函数指针变量 //通过 函数指针变量 调用函数 printf("函数add调用返回 = %d ",add(4,6)); printf("*fptr间接调用返回 = %d ",(*fptr)(4,6)); //间接调用add getchar(); }
3. 声明函数指针类型
//声明函数指针 类型
//int * pa; //声明了一个int * 变量pa
//typedef int * pa; //声明了一个 int * 类型的别名 pa
//pa p1,p2,p3; //声明了3个整形指针变量
类型名可以创建多个变量
typedef int (*pfunc)(int,int); //声明一个函数指针的类型pfunc
pfunc fp1,fp2,fp3,fp4; //用fptr 类型声明多个函数指针变量
#include <stdio.h> int add(int a,int b){ return a+b; } int (*fptr)(int,int); int main(){ fptr = add; //将函数add 的地址 赋值给函数指针变量 typedef int (*pfunc)(int,int); //声明一个函数指针的类型pfunc pfunc fp1,fp2,fp3,fp4; //用fptr 类型声明多个函数指针变量 fp1 = add; printf("函数fp1调用返回 = %d ",fp1(4,6)); //间接调用add getchar(); return 0; } 函数fp1调用返回 = 10
/*
* 函数指针
* 编写 剩下的三个函数
* int sub(int a,int b);
* int mul(int a,int b);
* int div(int a,int b);
*
* 将函数地址赋值给下面的函数指针变量,
* 通过函数指针变量退函数进行调用
*
pfunc fp1,fp2,fp3,fp4; //用fptr 类型声明多个函数指针变量
*/
#include <stdio.h> int add(int a,int b); int sub(int a,int b); int mul(int a,int b); int div(int a,int b); 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 (*fptr)(int,int); int main(){ typedef int (*pfunc)(int,int); //声明一个函数指针的类型pfunc pfunc fp1,fp2,fp3,fp4; //用fptr 类型声明多个函数指针变量 fp1 = add; fp2 = sub; fp3 = mul; fp4 = div; printf("函数fp1调用返回 = %d ",fp1(4,6)); //间接调用add printf("函数fp2调用返回 = %d ",fp2(4,6)); //间接调用add printf("函数fp3调用返回 = %d ",fp3(4,6)); //间接调用add printf("函数fp4调用返回 = %d ",fp4(4,6)); //间接调用add getchar(); return 0; } 函数fp1调用返回 = 10 函数fp2调用返回 = -2 函数fp3调用返回 = 24 函数fp4调用返回 = 0
4. 函数指针变量的使用 1. 函数指针变量作为 其他函数的参数 回调函数 2. 作为函数的返回值
/*
* 函数指针的使用
* 函数指针作为函数的参数
*/
#include <stdio.h> int add(int a,int b){ return a+b; } typedef int (*pfunc)(int,int); //声明了一个pfunc 的函数指针类型 //传入的第三参数是函数指针类型 int compute(int a,int b,pfunc opr); int compute(int a,int b,pfunc opr) { return opr(a,b); } int main(){ int a = 20; int b = 30; int c = 0; c = compute(a,b,add);//第三个参数是个回调函数 printf("add c = %d ",c); getchar(); return 0; } add c = 50
/*
* 函数指针作为 函数的返回值
*/
pfunc select(char opr) { if(opr == '+') return add; } typedef int (*pfunc)(int,int); //声明了一个pfunc 的函数指针类型 pfunc c; //定义变量名称为c的指针类型 c = select('+');//保存函数add的地址,而不是select的地址
函数指针作为 函数的返回值
#include <stdio.h> int add(int a,int b){ return a+b; } typedef int (*pfunc)(int,int); //声明了一个pfunc 的函数指针类型 pfunc select(char opr); pfunc select(char opr) { if(opr == '+') return add; } int main(){ int a = 20; int b = 30; pfunc c; //定义变量名称为c的指针类型 c = select('+');//保存函数add的地址 printf("c的地址:%p ",c); //?? printf("add 函数的地址:%p ",add); //?? printf("运算的结果 = %d ",c(a,b));//add(a,b) getchar(); return 0; } c的地址:00007FF6BE0E1000 add 函数的地址:00007FF6BE0E1000 运算的结果 = 50
/* * 函数指针作为 函数的返回值 */ #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; } typedef int (*pfunc)(int a,int b); pfunc select(char opr); pfunc select(char opr) { if(opr == '+') return add; if(opr == '-') return sub; if(opr == '*') return mul; if(opr == '/') return div; } int compute(int a,int b,char opr); int compute(int a,int b,char opr) { pfunc pf1; pf1 = select(opr); return pf1(a,b); } int main(){ printf("运算的结果 = %d ",compute(30,20,'*')); printf("运算的结果 = %d ",compute(30,20,'-')); printf("运算的结果 = %d ",compute(30,20,'+')); printf("运算的结果 = %d ",compute(30,20,'/')); getchar(); 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; } typedef int (*pfunc)(int a,int b); pfunc pf_arry[127]; void initArry() { pf_arry['+'] = add; pf_arry['-'] = sub; pf_arry['*'] = mul; pf_arry['/'] = div; } int compute(int a,int b,char opr) { pfunc pf1 = pf_arry[opr]; return pf1(a,b); } int main(){ //要初始化数组 initArry(); printf("运算的结果=%d ",compute(12,23,'+')); getchar(); return 0; }
运算的结果=35
//在main函数中 添加代码 可以实现 输入一个表达式
//输出该表达式的结果
#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; } typedef int (*pfunc)(int a,int b); pfunc pf_arry[127]; void initArry() { pf_arry['+'] = add; pf_arry['-'] = sub; pf_arry['*'] = mul; pf_arry['/'] = div; } int compute(int a,int b,char opr) { pfunc pf1 = pf_arry[opr]; return pf1(a,b); } int main(){ //要初始化数组 int as=12,bs=21; char cs='+'; printf("请输入一个表达式:"); scanf("%d%c%d",&as,&cs,&bs); initArry(); //在main函数中 添加代码 可以实现 输入一个表达式 //输出该表达式的结果 printf("运算的结果=%d ",compute(as,bs,cs)); getchar(); getchar(); return 0; }
请输入一个表达式:5+8
运算的结果=13
标准函数库
函数库 有很多函数组成
printf();
scanf();
time();
rand();
srand();
strlen();
strcmp();
strcpy();
atoi();
abs();
内存管理库函数
动态内存分配函数
在程序运行中,根据需要临时分配一块内存,就是动态内存分配.
要申请的内存空间需要程序员手动(显式调用函数)申请,手动释放
void *malloc(size_t size);
可以向系统动态申请连续内存,#include <stdlib.h>
唯一参数 申请内存的字节数
如果申请成功返回 申请内存的首地址,申请不成功返i回NULL.
返回值的类型: void * 空指针 没有类型的指针
如果要使用该内存地址 需要将空指针 转换为有类型的指针
int *p =(int *) malloc(4); //申请了4个字节,
*p = 200;//将200 写到 malloc 分配的内存中
void free(void *ptr); 释放动态申请到的内存,参数为要释放内存的首地址 释放的内存是一个整体
/*
* 申请动态内存并使用 释放
*
*/
#include <stdio.h> #include <stdlib.h> int main(){ int *pi = NULL; pi = (int *)malloc(4); *pi = 200; printf("*pi = %d ",*pi); free(pi); pi = NULL; //pi原来指向的内存已经被free,pi赋值为NULL getchar(); return 0; }
/*
* 申请动态内存并使用 释放
* [练习]
* 1. 申请其他基本类型 动态内存,并使用, 使用后注意释放
* 2. 申请一个Student类型的动态内存,并使用.注意释放
*/
#include <stdio.h> #include <stdlib.h> int main(){ float *pi = NULL; pi = (float *)malloc(4); *pi = 200.2; printf("*pi = %.2f ",*pi); free(pi); pi = NULL; //pi原来指向的内存已经被free,pi赋值为NULL getchar(); return 0; }
#include <stdio.h> #include <stdlib.h> #include <string.h> typedef struct { char name[20]; int score; int age; }Student; int main(){ Student *pi = NULL; pi = (Student *)malloc(sizeof(Student)); strcpy(pi->name,"如花"); pi->score = 30; pi->age = 18; printf("name = %s ",pi->name); printf("score= %d ",pi->score); printf("age = %d ",pi->age); free(pi); pi = NULL; //pi原来指向的内存已经被free,pi赋值为NULL getchar(); return 0; }
把功能放在函数
#include <stdio.h> #include <stdlib.h> #include <string.h> typedef struct { char name[20]; int score; int age; }Student; Student *input(){//返回一个结构体类型指针的函数 Student *pi = NULL; pi = (Student *)malloc(sizeof(Student)); strcpy(pi->name,"如花"); pi->score = 30; pi->age = 18; return pi;//返回一个结构体类型指针 } void output(Student* pi){ printf("name = %s ",pi->name); printf("score= %d ",pi->score); printf("age = %d ",pi->age); } int main(){ Student *ps = NULL; ps=input(); output(ps); free(ps); ps = NULL; //pi原来指向的内存已经被free,pi赋值为NULL getchar(); return 0; }
calloc
void *calloc(size_t nmemb, size_t size);
calloc 对动态分配的内存 清0
第一个参数 要分配多少个存储单元
第二个参数 每一单元的字节数是多少
malloc(10*sizeof(Student)); //分配10个学员结构体的空间
calloc(10,sizeof(Student)); //分配10个学员结构体的空间
void *realloc(void *ptr, size_t size);
如果malloc 分配的空间 不够,可以通过realloc 在原来的内存基础上 往后继续分配
第一个参数,是前面malloc 分配的首地址,需要重新分配的大小
int *p = (int *)malloc(10);
p = (int *)realloc(p,20); //在原来地址的基础上 分配20字节
calloc realloc 调用 也需要free
time(0); //返回 从1970.1.1 0:0:0 到现在的秒数
time_t time(time_t *tloc);
也可以通过传入一个time_t(unsigned int *)指针,带回秒数
#include <stdio.h> #include <time.h> int main(){ unsigned int sec =0; sec = time(0); printf("%u ",sec); getchar(); return 0; }
char *ctime(const time_t *timep);
对输入的秒数 转换为日历字符串进行输出
#include <time.h> #include <stdio.h> int main() { time_t timer; timer=time(NULL); printf("%s ",ctime(&timer)); getchar(); return 0; } Wed May 20 15:58:39 2020
pt = localtime(&timer); //可以定制显示日历信息
#include <time.h> #include <stdio.h> int main() { time_t timer; timer=time(NULL); struct tm * pt = NULL; printf("%s ",ctime(&timer)); pt = localtime(&timer); //可以定制显示日历信息 printf("今天%d号,%d月,%d年 ",pt->tm_mday,pt->tm_mon+1,pt->tm_year+1900); getchar(); return 0; } Wed May 20 16:04:07 2020 今天20号,5月,2020年
char *asctime(const struct tm *tm);
对传入的结构体指针 转换输出日历字符串 跟ctime相同
#include <time.h> #include <stdio.h> int main() { time_t timer; timer=time(NULL); struct tm * pt = NULL; printf("%s ",ctime(&timer)); pt = localtime(&timer); //可以定制显示日历信息 printf("今天%d号,%d月,%d年 ",pt->tm_mday,pt->tm_mon+1,pt->tm_year+1900); printf("asctime = %s ",asctime(pt)); //跟ctime 效果一样 getchar(); return 0; } Wed May 20 16:07:07 2020 今天20号,5月,2020年 asctime = Wed May 20 16:07:07 2020
打印时分秒
printf("秒%d,分%d,时%d,今天%d号,%d月,%d年 ",pt->tm_sec,pt->tm_min,pt->tm_hour, pt->tm_mday,pt->tm_mon+1,pt->tm_year+1900); 秒23,分14,时16,今天20号,5月,2020年
struct tm *gmtime(const time_t *timep);
格林威治 时间
而Linux系统下
/* * 时间函数 */ #include <stdio.h> #include <time.h> // typedef long int time_t int main(){ long int sec = 0; struct tm * pt = NULL; //sec = time(0); time(&sec); printf("sec = %ld ",sec); printf("ctime = %s ",ctime(&sec)); //输出固定格式日历字符串 pt = localtime(&sec); //可以定制显示日历信息 printf("今天%d号,%d月,%d年 ",pt->tm_mday,pt->tm_mon+1,pt->tm_year+1900); //打印时分秒 printf("asctime = %s ",asctime(pt)); //跟ctime 效果一样 return 0; }