一、前言C语言，是一种通用的、过程式的编程语言，广泛用于系统与应用软件的开发。具有高效、灵活、功能丰富、表达力强和较高的移植性等特点，在程序员中备受青睐。最近25年是使用最为广泛的编程语言。 C语言的设计影响了许多后来的编程语言，例如C++、Objective-C、Java、C#等。 目前C语言主要是用在底层开发领域，比如： （1）嵌入式Linux应用软件开发工程设计； （2）嵌入式Linux驱动开发工程师； （3）嵌入式BSP开发工程师； （4）嵌入式Kernel（内核）开发工程师； （5）物联网底层开发工程师   因为操作系统的内核都是使用的C语言，而且C语言也有如下几个优点： （1）出色的移植性，能在多种不同体系结构的软/硬平台上运行（修改量越小，移植性越好）； （2）简洁紧凑，使用灵活的语法机制，并能直接访问硬件（效率高）； （3）C语言有很高的运行效率。 二、C语言系列文章集合1. C语言总结_格式化打印函数、字符串、运算符cid:link_0字符串函数的运用、sprintf、sscanf、main标准形参、变量和常量定义、基本数据占用字节数总结、scanf函数输入数据、位运算全面介绍、基本运算符全面介绍。2. C语言总结_函数知识cid:link_1这篇介绍C语言里函数的定义、子函数的使用。接着介绍变量的作用域，定义全局变量、静态变量、只读变量、变量初始化等等。3. C语言总结_数组全方位练习复盘C语言数组的练习题：涉及到数组插入、数组删除、数组下标数据的左移右移、数组排序、数组排序优化、数组的数据拼接等等。（1）函数基本使用: 函数基本定义、封装、传参、调用、局部变量、全局变量、只读变量、静态变量（2）数组基本使用: 数组基本定义、使用赋值、字符串。cid:link_24. C语言总结_数组与函数传参练习题字符串标准处理函数介绍（string.h）、指针和数组当做函数形参，指针定义、函数返回指针、void类型定义指针、类型强制转换、常量声明、extern外边引用声明关键字。cid:link_35. C语言总结_数组知识当前文章复盘C语言的数组： 数组定义规则、数组空间类型、数组下标使用、数组存放的数据类型、数组数据替换、插入、输入、输出、字符串输入、输出、长度计算等等。cid:link_46. C语言总结_语句、运算符当前文章复盘C语言的： 位运算运算符、基本运算符、数据类型、变量、for语句、while语句、goto语句、switch语句、运算符优先级强制转换等。cid:link_57. C语言总结_字符串函数封装练习字符串函数重写练习：字符串比较、字符串拼接、字符串查找、字符串拷贝、内存比较、内存拷贝、内存初始化、内存比较、二维数组定义及基本使用、位运算练习--通过取模打印中文字模在控制台。cid:link_68. C语言总结_字符串全方位练习C语言字符串全方位练习，涉及知识点：字符串解析、大小写判断、字符串插入、字符串删除、字符串排序、字符串转整数、字符串转浮点数、时间转换、GPS数据解析等等。cid:link_79. WebAssembly技术_编译ffmpeg(ubuntu20.04)WebAssembly/wasm WebAssembly 或者 wasm 是一个可移植、体积小、加载快并且兼容 Web 的全新格式。WebAssembly的名字带个汇编Assembly，所以我们从其名字上就能知道其意思是给Web使用的汇编语言，是通过Web执行低级二进制语法。但是WebAssembly并不是直接用汇编语言，而提供了抓换机制（LLVM IR），把高级别的语言（C，C++和Rust）编译为WebAssembly，以便有机会在浏览器中运行。主要是解决目前JS语言的效率问题，设计立足点为快速，内存安全和开放。所以是一种运行机制，一种新的字节码格式(.wasm)cid:link_811. C语言_Linux基本命令与C语言基础这篇文章介绍在Linux环境下学习C语言搭建基本的环境过程，了解基础的几个命令使用方法，了解Linux下用户权限配置，标准main函数传参方式等等。cid:link_912. C语言_语句与位运算基本练习总结C语言语句的几个基本练习题，计算素数、排序、求偶数和、可逆素数、水仙花数、交换大小写、交换变量的值、位运算、语法特性等知识点。cid:link_1013. C语言_数组的查找、替换、排序、拼接这篇文章主要是总结C语言的位运算几个实战例子，接着介绍数组的基本定义用法、数组排序、插入、拼接、删除、字符串查找替换等。cid:link_1114. C语言_函数封装、变量的作用域这篇文章介绍C语言函数封装以及变量作用域、字符串的相关实战练习。字符串转整数、整数转字符串、浮点数转字符串、字符串转浮点数、判断平年闰年、技术字符串长度等等。cid:link_1215. C语言_标准时间与秒单位的转换这篇文章介绍 标准时间与秒单位，秒单位与标准时间的转换方式，这份代码一般用在嵌入式单片机里比较多，比如：设置RTC时钟的时间，从RTC里读取秒单位时间后，需要转换成标准时间显示。cid:link_1316. C语言_字符串与指针的练习这篇文章涉及到字符串与指针知识点的相关练习。浮点数与字符串互转、字符串拷贝、字符串比较、指针交换变量、指针优先级、数据类型强制转换、内存拷贝函数等。cid:link_14

这篇文章涉及到字符串与指针知识点的相关练习。浮点数与字符串互转、字符串拷贝、字符串比较、指针交换变量、指针优先级、数据类型强制转换、内存拷贝函数等。1. 浮点数转字符串将字符串转整数、整数转字符串、浮点数转字符串、字符串转浮点数 封装为函数。 浮点数转字符串:#include #include //字符串处理 void float_to_string(char str[],float data); int main(void) { char buff[50]; float data=1234.5; float_to_string(buff,data); printf("data=%f,buff=%s\n",data,buff); return 0; } /* 函数功能: 浮点数转字符串 */ void float_to_string(char str[],float data) { int buff[50]; int int_data1=data; //提取整数部分 int int_data2=(data-int_data1)*1000000; //提取小数部分 int i=0,j=0,k=0; //转整数部分 while(int_data1) { buff[i]=int_data1+'0'; int_data1=int_data1/10; i++; } //倒序 for(j=0;j=0; j--) { if(str[j]=='0')str[j]='\0'; //添加结束符 else break; } }2. 封装字符串拼接函数封装字符串拼接函数:函数功能实现将a和b字符串拼接在一起。比如: char a[100]=”123”; char b[]=”456”; 调用函数之后: a[]=”123456”#include #include //字符串处理 void my_strcat(char str1[],char str2[]); int main(void) { char str1[50]="12345"; char str2[]="67890"; //strcat(str1,str2); //字符串拼接 my_strcat(str1,str2); //字符串拼接 printf("%s\n",str1); return 0; } /* 函数功能:字符串拼接 */ void my_strcat(char str1[],char str2[]) { int i=0,len=0; while(str1[len]!='\0') { len++; } while(str2[i]!='\0') { str1[len+i]=str2[i]; i++; } str1[len+i]='\0'; //结尾补上'\0' }3. 封装字符串的拷贝函数封装字符串的拷贝函数: 将a字符串拷贝到b字符串。 示例:#include #include //字符串处理 void my_strcpy(char str1[],char str2[]); int main(void) { char str1[50]="12345"; char str2[]="67890"; //strcpy(str1,str2); //字符串拷贝 my_strcpy(str1,str2); printf("%s\n",str1); return 0; } /* 函数功能:字符串拼接 */ void my_strcpy(char str1[],char str2[]) { int i=0,len=0; while(str2[i]!='\0') { str1[i]=str2[i]; //依次赋值 i++; } str1[i]='\0'; //补上结尾符号 }4. 封装字符串的比较函数封装字符串的比较函数: 比较a字符串和b字符串是否相等。 通过返回值进行区分。 示例:#include #include //字符串处理 int my_strcmp(char str1[],char str2[]); int main(void) { char str1[50]="中国"; char str2[]="中国"; int a; //a=strcmp(str1,str2); a=my_strcmp(str1,str2); if(a==0)printf("字符串相等!\n"); else printf("字符串不相等!\n"); return 0; } /* 函数功能:字符串比较 */ int my_strcmp(char str1[],char str2[]) { int i=0; //只要有一个数组没结束就继续 while(str1[i]!='\0'||str2[i]!='\0') { if(str1[i]!=str2[i])break; i++; } if(str1[i]=='\0' && str2[i]=='\0')return 0; //相等 else return -1; //不相等 }5. 指针特性指针: 是C语言的灵魂。 指针: 可访问计算机的底层----->硬件。 定义指针的语法: <数据类型> *<变量名称>; int *p; 指针的特性:(1)指针本身没有空间。int *p; //定义一个指针变量 (2)指针本身就是地址(专门保存地址)。int *p; p=? ？必须是地址类型。 int *p; //定义一个指针变量 int data=123; //p=123; //错误赋值方式 p=&data; //正确的赋值方式 (3)取出指针指向地址的数据 int *p; //定义一个指针变量 int data=123; p=&data; //正确的赋值方式 printf("Óf6b5d2a-2892-4803-bef4-d6dc767a05c5n",*p); //取出p指针指向空间的值 //*p=888; (4)指针类型的变量都是占4个字节 #include int main() { int *p1; //定义一个整型指针变量 char *p2; float *p3; double *p4; printf("int=Óf6b5d2a-2892-4803-bef4-d6dc767a05c5n",sizeof(p1)); printf("char=Óf6b5d2a-2892-4803-bef4-d6dc767a05c5n",sizeof(p2)); printf("float=Óf6b5d2a-2892-4803-bef4-d6dc767a05c5n",sizeof(p3)); printf("double=Óf6b5d2a-2892-4803-bef4-d6dc767a05c5n",sizeof(p4)); return 0; } (5)指针支持自增和自减 ++ -- #include int main() { char *p; char str[]="1234567890"; p=str; //将数组地址赋值给指针p //指针可以直接使用数组下标(指针可以当数组名使用) printf("Ãf6b5d2a-2892-4803-bef4-d6dc767a05c5n",p[0]);//1 printf("Ãf6b5d2a-2892-4803-bef4-d6dc767a05c5n",p[1]);//2 //通过指针访问数组的成员 printf("Ãf6b5d2a-2892-4803-bef4-d6dc767a05c5n",*p); //1 p++; //指针自增 printf("Ãf6b5d2a-2892-4803-bef4-d6dc767a05c5n",*p); //2 p--; printf("Ãf6b5d2a-2892-4803-bef4-d6dc767a05c5n",*p); //1 return 0; } (6) 不同类型的指针自增和自减的字节数 //指针类型自增和自减的字节数与本身数据类型有关。 #include int main() { int data1[10]; char data2[10]; /*1. 给指针赋值合法的空间*/ int *p1=data1; char *p2=data2; printf("0x%X\n",p1); p1++; printf("0x%X\n",p1); printf("0x%X\n",p2); p2++; printf("0x%X\n",p2); return 0; }6. 通过指针交换两个变量的值#include void func(int *a,int *b); int main() { int a=100,b=200; func(&a,&b); printf("a=%d,b=Óf6b5d2a-2892-4803-bef4-d6dc767a05c5n",a,b); //200,100 return 0; } //通过指针交换两个变量的值 void func(int *a,int *b) { int c; c=*a; //取出100 *a=*b; //取出200赋值给a *b=c; }7. 指针自增优先级#include int main() { char buff[]="12345"; char *p=buff; printf("Ãf6b5d2a-2892-4803-bef4-d6dc767a05c5n",*p); //1 printf("Ãf6b5d2a-2892-4803-bef4-d6dc767a05c5n",*p++); //1 printf("Ãf6b5d2a-2892-4803-bef4-d6dc767a05c5n",*p++); //2 printf("Ãf6b5d2a-2892-4803-bef4-d6dc767a05c5n",*p); //3 return 0; }8. 计算字符串的长度#include int my_strlen(const char *str); int main() { printf("Óf6b5d2a-2892-4803-bef4-d6dc767a05c5n",my_strlen("1234567")); return 0; } //加const为了防止不小心修改了数据 int my_strlen(const char *str) { //*str='1'; //错误，不能赋值 char *p=str; //保存地址 while(*p!='\0')p++; return p-str; //得到字符串长度 }9. 数据类型的强制转换数据类型的强制转换 (欺骗编译器) char *p1=(char*)src; char *p2=(char*)new;10. 编写一个内存拷贝函数功能: 可以将任何数据的类型进行相互赋值。 int a,b=100; float a,b=123.456; ……….. #include void my_memcpy(void *new,void *src,int len); int main() { //int data1=123,data2=456; //my_memcpy(&data1,&data2,4); //printf("data1=Óf6b5d2a-2892-4803-bef4-d6dc767a05c5n",data1); int data1[100]; int data2[50]={12,34,5,6,78}; my_memcpy(data1,data2,sizeof(data2)); printf("Óf6b5d2a-2892-4803-bef4-d6dc767a05c5n",data1[0]); printf("Óf6b5d2a-2892-4803-bef4-d6dc767a05c5n",data1[1]); return 0; } /* 内存拷贝 将src的数据拷贝到new,拷贝len */ void my_memcpy(void *new,void *src,int len) { char *p1=(char*)src; char *p2=(char*)new; int i; //for(i=0; i

这篇文章介绍 标准时间与秒单位，秒单位与标准时间的转换方式，这份代码一般用在嵌入式单片机里比较多，比如：设置RTC时钟的时间，从RTC里读取秒单位时间后，需要转换成标准时间显示。下面列出的两个例子里，注释和思路都写了，思路和实现办法在代码注释里。1. 时间转换-秒与标准时间的转换1.时间转换(秒与标准时间的转换) (1)函数1: 将秒单位时间转为标准时间。 --RTC实时时钟--->秒为单位--->每秒钟cnt++; 237562867493 -----xxxx年xx月xx日xx时xx分xx秒 星期x。示例代码: (模拟电子钟) #include #include //字符串处理 #include //时间单位 int year,mon,mdeay,hour,min,t_sec; //闰年的月份 int mon_r[12]={31,29,31,30,31,30,31,31,30,31,30,31}; //平年的月份 int mon_p[12]={31,28,31,30,31,30,31,31,30,31,30,31}; unsigned int TimeToSec(int year,int mon,int mdeay,int hour,int min,int sec); void SecToTime(unsigned int sec); int main(void) { //将标准时间转为秒单位时间 (设置时间) unsigned int time=TimeToSec(2018,6,6,16,40,20); while(1) { time++; Sleep(1000); //睡眠1秒时间。 单位是ms SecToTime(time); printf("%d-%d-%d %d:%d:Øaa09000-b858-4f26-b859-374644ed16den",year,mon,mdeay,hour,min,t_sec); } return 0; } /* 函数功能: 判断平年和闰年 函数返回值: 1表示闰年 0表示平年 */ int GetYearStat(int year) { if((year%4==0&&year0!=0)||year@0==0)return 1; //闰年 return 0; //平年 } /* 将秒单位时间转为标准时间 时间基准点: 1970年1月1日0时0分0秒 思想: 减法 */ void SecToTime(unsigned int sec) { int i; year=1970; //基准年份 /*1. 计算过了多少年*/ while(sec>=365*24*60*60) //秒还够一年 { if(GetYearStat(year)) //闰年 { if(sec>366*24*60*60) { sec-=366*24*60*60; //减去一年 year++; //年份累加 } else { break; } } else { sec-=365*24*60*60; //减去一年 year++; //年份累加 } } /*2. 计算过了多少月*/ mon=1; if(GetYearStat(year)) //闰年 { for(i=0; i<12; i++) { if(sec>=mon_r[i]*24*60*60) //够一个月 { sec-=mon_r[i]*24*60*60; //减去一个月 mon++;//增加一个月 } else break; } } else { for(i=0; i<12; i++) { if(sec>=mon_p[i]*24*60*60) //够一个月 { sec-=mon_p[i]*24*60*60; //减去一个月 mon++;//增加一个月 } else break; } } /*3. 计算过了多少天*/ mdeay=1; while(sec>=24*60*60) //判断是否够一天 { sec-=24*60*60; mdeay++; } /*4. 过了多少小时*/ hour=0; while(sec>=60*60) { sec-=60*60; hour++; } /*5. 过了多少分钟*/ min=0; while(sec>=60) { sec-=60; min++; } /*6. 过了多少秒*/ t_sec=sec; } /* 将标准时间转为秒单位时间 思路: 全程加法 时间基准点: 1970年1月1日0时0分0秒 返回值: 得到的秒单位时间 */ unsigned int TimeToSec(int year,int mon,int mdeay,int hour,int min,int sec) { int i; int sec_cnt=0; //记录秒单位的时间 /*1. 转换年*/ for(i=1970; i #include //字符串处理 #include //时间单位 int year,mon,mdeay,hour,min,t_sec,week; //闰年的月份 int mon_r[12]={31,29,31,30,31,30,31,31,30,31,30,31}; //平年的月份 int mon_p[12]={31,28,31,30,31,30,31,31,30,31,30,31}; unsigned int TimeToSec(int year,int mon,int mdeay,int hour,int min,int sec); void SecToTime(unsigned int sec); int GetWeek(unsigned int sec); int main(void) { //将标准时间转为秒单位时间 (设置时间) unsigned int time=TimeToSec(2018,9,1,16,40,20); while(1) { time++; Sleep(1000); //睡眠1秒时间。 单位是ms SecToTime(time); week=GetWeek(time); //获取星期 printf("%d-%d-%d %d:%d:%d 星期Øaa09000-b858-4f26-b859-374644ed16den",year,mon,mdeay,hour,min,t_sec,week); } return 0; } /* 函数功能: 判断平年和闰年 函数返回值: 1表示闰年 0表示平年 */ int GetYearStat(int year) { if((year%4==0&&year0!=0)||year@0==0)return 1; //闰年 return 0; //平年 } /* 将秒单位时间转为标准时间 时间基准点: 1970年1月1日0时0分0秒 思想: 减法 */ void SecToTime(unsigned int sec) { int i; year=1970; //基准年份 /*1. 计算过了多少年*/ while(sec>=365*24*60*60) //秒还够一年 { if(GetYearStat(year)) //闰年 { if(sec>366*24*60*60) { sec-=366*24*60*60; //减去一年 year++; //年份累加 } else { break; } } else { sec-=365*24*60*60; //减去一年 year++; //年份累加 } } /*2. 计算过了多少月*/ mon=1; if(GetYearStat(year)) //闰年 { for(i=0; i<12; i++) { if(sec>=mon_r[i]*24*60*60) //够一个月 { sec-=mon_r[i]*24*60*60; //减去一个月 mon++;//增加一个月 } else break; } } else { for(i=0; i<12; i++) { if(sec>=mon_p[i]*24*60*60) //够一个月 { sec-=mon_p[i]*24*60*60; //减去一个月 mon++;//增加一个月 } else break; } } /*3. 计算过了多少天*/ mdeay=1; while(sec>=24*60*60) //判断是否够一天 { sec-=24*60*60; mdeay++; } /*4. 过了多少小时*/ hour=0; while(sec>=60*60) { sec-=60*60; hour++; } /*5. 过了多少分钟*/ min=0; while(sec>=60) { sec-=60; min++; } /*6. 过了多少秒*/ t_sec=sec; }2. 时间转换-标准时间转秒(2)函数2: 将标准时间转为秒单位的时间。 2018年6月1日19点41分23秒----------xxxxxxx秒 闰年366，平年365。 区分: 每年二月份相差一天. 标准时间基准点: 1970年1月1日0时0分0秒。/* 将标准时间转为秒单位时间 思路: 全程加法 时间基准点: 1970年1月1日0时0分0秒 返回值: 得到的秒单位时间 */ unsigned int TimeToSec(int year,int mon,int mdeay,int hour,int min,int sec) { int i; int sec_cnt=0; //记录秒单位的时间 /*1. 转换年*/ for(i=1970; i

这篇文章介绍C语言函数封装以及变量作用域、字符串的相关实战练习。字符串转整数、整数转字符串、浮点数转字符串、字符串转浮点数、判断平年闰年、技术字符串长度等等。1. for循环示例#include int main() { int i,j; int len=4; for(i=len; i>=1; i--) { for(j=len; j>i; j--)printf(" "); //打印空格 for(j=1; j<=i; j++)printf("%d",j); //打印前半部分 for(j=i-1; j>=1; j--)printf("%d",j); //打印后半部分 printf("\n"); } return 0; }2. 模拟实现投票系统。switch比如: 有10张票，3个候选人。 进行投票，最终得出票数。 #include int main() { int i; int val; //获取键盘上输入的值 int cnt1=0,cnt2=0,cnt3=0,cnt4=0; for(i=1; i<=10; i++) { printf("请输入投票的编号(1~3,4表示无效票) 剩余票数(%d) :",10-i); scanf("%d",&val); switch(val) { case 1: cnt1++; break; case 2: cnt2++; break; case 3: cnt3++; break; default: cnt4++; break; } } printf("1号选手:Óf8b3e5d-c54f-43f3-ad97-158a6758d930n",cnt1); printf("2号选手:Óf8b3e5d-c54f-43f3-ad97-158a6758d930n",cnt2); printf("3号选手:Óf8b3e5d-c54f-43f3-ad97-158a6758d930n",cnt3); printf("无效票数:Óf8b3e5d-c54f-43f3-ad97-158a6758d930n",cnt4); return 0; }3. 计算字符串空格、数字等数据数量1.从键盘上输入一个字符串 计算字符串里有多少个空格、小写字母、大写字母、数字。 scanf("%s",buff); /* scanf 函数依靠 \n和空格代表结束符号 */ #include int main() { char buff[100]; int i=0; int cnt1=0,cnt2=0,cnt3=0,cnt4=0,cnt5=0; printf("请输入字符串:"); gets(buff); while(buff[i]!='\0') { if(buff[i]==' ') { cnt1++; } else if(buff[i]>='a'&& buff[i]<='z') { cnt2++; } else if(buff[i]>='A'&& buff[i]<='Z') { cnt3++; } else if(buff[i]>='0'&& buff[i]<='9') { cnt4++; } else { cnt5++; } i++; } printf("空格:Óf8b3e5d-c54f-43f3-ad97-158a6758d930n",cnt1); printf("小写:Óf8b3e5d-c54f-43f3-ad97-158a6758d930n",cnt2); printf("大写:Óf8b3e5d-c54f-43f3-ad97-158a6758d930n",cnt3); printf("数字:Óf8b3e5d-c54f-43f3-ad97-158a6758d930n",cnt4); printf("其他:Óf8b3e5d-c54f-43f3-ad97-158a6758d930n",cnt5); return 0; }4. 字符串转整数。2.字符串转整数。 从键盘上输入一个字符串”12345”, int data=12345; #include //"1234" int main() { char buff[100]; int i=0,value=0; printf("输入数字字符串(0~9):"); scanf("%s",buff); while(buff[i]>='0' && buff[i]<='9') //实现字符串转整数 { value=value*10; //0 10 120 1230 value=value+(buff[i]-'0'); //1 12 123 1234 i++; } if(buff[i]!='\0') //转换失败 { printf("警告:转换不完整。 得到的值:Óf8b3e5d-c54f-43f3-ad97-158a6758d930n",value); } else { printf("转换成功! 正确值=Óf8b3e5d-c54f-43f3-ad97-158a6758d930n",value); } return 0; }5. 整数转字符串3.整数转字符串 #include //1234 int main() { char buff[100]; char str[100]; unsigned int i=0,val=0,j; printf("请输入一个整数:"); scanf("%d",&val); while(val) { buff[i]=val+'0'; //"4321" val=val/10; i++; } for(j=0; j6. 浮点数转字符串浮点数转字符串 //以下例子代码实现将浮点数分解成两个整数 #include //1234 int main() { float data=123.456789; int data1,data2; data1=data; //得到整数部分 data2=(data-data1)*1000000; printf("%d.Óf8b3e5d-c54f-43f3-ad97-158a6758d930n",data1,data2); return 0; }7. 字符串转浮点数从键盘上输入一个字符串”123.45”, float data=123.45; printf("Óf8b3e5d-c54f-43f3-ad97-158a6758d930n",0); //0 printf("Óf8b3e5d-c54f-43f3-ad97-158a6758d930n",'0'); //488. 函数的特性与用法C语言是靠函数组成。 函数的特性： 1.函数就相当于封装一个工具。 2.函数可以重复调用。 3.函数的功能尽可能的单一。 比如：判断闰年和平年 4.我们自己的写的函数，(除了main函数之外) 子函数。 5.一般情况下，子函数的代码都在main函数的下面。 6.在调用任何子函数之前，都需要声明。 函数的定义: <函数返回值类型> 函数的名称(形参1,形参2…….) { 函数的代码…… return <返回值值>; //如何函数有返回值才需要返回 } 函数的模型: void func1(void); //函数声明 int func1(int data1,int data2 /*,......*/); //函数声明 //函数原型 void func1(void) { } //函数原型 int func1(int data1,int data2 /*,......*/) { return 100; } 函数示例(计算和): #include int sum(int a,int b); //函数声明 int main() { int data; data=sum(100,200); ///调用sum函数，并且接收返回值 printf("data=Óf8b3e5d-c54f-43f3-ad97-158a6758d930n",data); data=sum(300,500); ///调用sum函数，并且接收返回值 printf("data=Óf8b3e5d-c54f-43f3-ad97-158a6758d930n",data); return 0; } /* 函数功能: 计算a+b之和 */ int sum(int a,int b) { int c=a+b; return c; }9. 判断平年和闰年判断平年和闰年 #include int GetYear(int year); //函数声明 int main() { int i; for(i=2001; i<2018; i++) { if(GetYear(i))printf("%d 是闰年.\n",i); else printf("%d 是平年.\n",i); } return 0; } /* 函数功能 : 判断平年和闰年 函数返回值: 0表示平年 1表示闰年 */ int GetYear(int year) { if((year%4==0&&year0!=0)||(year@0==0)) { return 1; } else { return 0; } }10. 将数组当做函数的形参#include void print(char buff[]); int main() { char buff[]="34534r4gyhtrvfvfdvdf"; print(buff); print(buff); print(buff); print(buff); return 0; } void print(char buff[]) { printf("buff=%s\n",buff); }11. 计算字符串长度函数示例: 封装函数，计算字符串长度 #include int my_strlen(char buff[]); int main() { char buff[100]; scanf("%s",buff); printf("字符串长度:Óf8b3e5d-c54f-43f3-ad97-158a6758d930n",my_strlen(buff)); return 0; } /* 函数功能: 计算字符串长度 返回值 : 字符串的长度 */ int my_strlen(char buff[]) { int len=0; while(buff[len]!='\0') { len++; } return len; }12. 全局变量、静态变量、局部变量、常量如何声明常量? 示例: 常量和变量的区别测试 #include int main() { int data1=123; //默认声明为变量 const int data2=456;//声明为常量 //区别: 变量可以改变数据 常量不可改变数据 data1=789; //data2=789; 错误赋值方式 return 0; } 全局变量和局部变量区别： #include void func(void); int data=123; //全局变量，定义在函数之外的变量。 公用变量 int main(void) { int data=456; //局部变量，私有变量 printf("data1=Óf8b3e5d-c54f-43f3-ad97-158a6758d930n",data); //当全局变量和局部变量重名的时候，优先使用局部变量 func(); //调用函数 return 0; } void func(void) { printf("data2=Óf8b3e5d-c54f-43f3-ad97-158a6758d930n",data); //使用全局 } 局部变量传参数示例： (分析局部变量) #include void func(int data); int main(void) { int data=456; //局部变量，私有变量 func(data); printf("data1=Óf8b3e5d-c54f-43f3-ad97-158a6758d930n",data); return 0; } void func(int data) { data=9999; printf("data2=Óf8b3e5d-c54f-43f3-ad97-158a6758d930n",data); } 函数形参传递数组和传递变量的区别： #include void func(int buff[],int data); int main(void) { int buff[10]={456,123,789}; //局部变量，私有变量 int data=888; printf("data1的地址=0x%X\n",&data); printf("buff1的地址=0x%X\n",buff); func(buff,data); //传递的是数组的首地址 printf("buff1=Óf8b3e5d-c54f-43f3-ad97-158a6758d930n",buff[0]); // 9999 ? printf("data=Óf8b3e5d-c54f-43f3-ad97-158a6758d930n",data); // 888 ? return 0; } /* 函数形参传递数组表示是传递地址 函数形参传递变量表示是传递数据 */ void func(int buff[],int data) { buff[0]=9999; data=9999; printf("data2的地址=0x%X\n",&data); printf("buff2的地址=0x%X\n",buff); } 全局变量和静态变量的生命周期与main函数一样长。 局部变量的声明周期与调用的子函数挂钩，子函数调用完毕，内部所有的局部变量全部释放。 什么是静态变量？ 局部的全局变量 如何声明? static 关键字。 示例: static int data; //表示声明data是静态变量 #include int func(void); int main(void) { int i; int sum=0; for(i=0; i<5; i++) { sum+=func(); //累加 } printf("Óf8b3e5d-c54f-43f3-ad97-158a6758d930n",sum); // ? return 0; } int func(void) { static int data=0; //声明静态变量，int data=0 只会执行一次。 data++; return data; }13. 字符串进阶练习作业函数的作业: 1.时间转换(秒与标准时间的转换) (1)函数1: 将秒单位时间转为标准时间。 237562867493 -----xxxx年xx月xx日xx时xx分xx秒 (2)函数2: 将标准时间转为秒单位的时间。 2018年6月1日19点41分23秒----------xxxxxxx秒 闰年366，平年365。 区分: 每年二月份相差一天 2.将字符串转整数、整数转字符串、浮点数转字符串、字符串转浮点数 封装为函数。 3.封装字符串拼接函数: 函数功能实现将a和b字符串拼接在一起。 比如: char a[100]=”123”; char b[]=”456”; 调用函数之后: a[]=”123456” 4.封装字符串的拷贝函数: 将a字符串拷贝到b字符串。 5.封装字符串的比较函数: 比较a字符串和b字符串是否相等。 通过返回值进行区分。 字符串解析(扩展): 1.分析GPS卫星返回的数据 提取最基本的数据： (1)UTC时间 (2)海拔高度 (3)经纬度 char gps_data[]= { "$GNGGA,114955.000,2842.4158,N,11549.5439,E,1,05,3.8,54.8,M,0.0,M,,*4F \ $GNGLL,2842.4158,N,11549.5439,E,114955.000,A,A*4D \ $GPGSA,A,3,10,31,18,,,,,,,,,,5.7,3.8,4.2*37 \ $BDGSA,A,3,07,10,,,,,,,,,,,5.7,3.8,4.2*2A \ $GPGSV,3,1,10,10,49,184,42,12,16,039,,14,54,341,,18,22,165,23*7B \ $GPGSV,3,2,10,22,11,318,,25,51,055,,26,24,205,,29,13,110,*7C \ $GPGSV,3,3,10,31,50,287,36,32,66,018,*7F \ $BDGSV,1,1,04,03,,,07,05,,,29,07,79,246,33,10,52,232,19*62 \ $GNRMC,114955.000,A,2842.4158,N,11549.5439,E,0.00,44.25,061117,,,A*4D \ $GNVTG,44.25,T,,M,0.00,N,0.00,K,A*14 \ $GNZDA,114955.000,06,11,2017,00,00*47 \ $GPTXT,01,01,01,ANTENNA OK*35" };

这篇文章主要是总结C语言的位运算几个实战例子，接着介绍数组的基本定义用法、数组排序、插入、拼接、删除、字符串查找替换等。1. 颜色转换的例子1.颜色转换的例子: RGB888 RGB565 RGB666…. int data=12345; //RGB888的颜色 要求将data转为RGB565 -去掉高位 示例: /* int data=101010101010101010101010 11184810 R:01010 G:101010 B:01010 0101010101001010 21834 10101010 00111111 */ #include int main(int argc, char * argv[]) { unsigned short rgb565_c; unsigned int data=11184810; //RGB888 unsigned char r=(data>>16)&0xFF; unsigned char g=(data>>8)&0xFF; unsigned char b=(data>>0)&0xFF; printf("RGB88_r=0x%X\n",r); printf("RGB88_g=0x%X\n",g); printf("RGB88_b=0x%X\n",b); r&=0x1F; //5 g&=0x3F; //6 b&=0x1F; //5 rgb565_c=(r<<11)|(g<<5)|(b<<0); printf("rgb565_c=Ú42a8d92-5935-47c5-9355-2a286c0e151en",rgb565_c); return 0; }2. 位运算综合练习2.位运算综合练习 #include int main(int argc,char **argv) { /*1. 存放数据*/ data|='A'<<24; data|='B'<<16; //F data|='C'<<8; data|='D'<<0; /*2. 修改数据*/ data&=~(0xFF<<8*2); //清除指定位 data|='F'<<16; /*3. 取出数据*/ printf("Ê42a8d92-5935-47c5-9355-2a286c0e151en",(data>>24)&0xFF); printf("Ê42a8d92-5935-47c5-9355-2a286c0e151en",(data>>16)&0xFF); printf("Ê42a8d92-5935-47c5-9355-2a286c0e151en",(data>>8)&0xFF); printf("Ê42a8d92-5935-47c5-9355-2a286c0e151en",(data>>0)&0xFF); return 0; }3. 位运算实际的运用3.实际的运用 short c1=1234; //R占11~15位 G占2~7位 short c2=4567; //B占 11~15位 RGB565; 要求: 将以上RGB分量提取出来，存在另一个变量(16位的变量)中—RGB565 。 unsigned int data_1; //整型 4个字节 unsigned short data_2; //短整型 2个字节 unsigned long data_3; //长整型 4个字节 unsigned long long data_3; //双长整型 8个字节 示例: /* short c1=1234; //R占11~15位 G占2~7位 short c2=4567; //B占 11~15位 c1=101010101010101010101010 11184810 c2=101010101010101010101010 11184810 r: 10101 g: 101010 b: 10101 rgb565=1010110101010101 44373 */ #include int main(int argc, char * argv[]) { unsigned int c1=11184810; unsigned int c2=11184810; unsigned char r,g,b; unsigned short c3; /*1. 转换为RGB888*/ r=c1>>8; g=c1&0xFF; b=c2>>8; /*2. 转换为RGB565*/ r=r>>3; g=g>>2; b=b>>3; /*3. 组合颜色*/ c3=(r<<11)|(g<<5)|(b<<0); printf("c3=Ú42a8d92-5935-47c5-9355-2a286c0e151en",c3); return 0; }4. 数组特点介绍内存空间: 都是连续的---线性空间。 数组类型定义: <数据类型> 数组的名称[数组的大小]; int buff[100]; 数组的特性： (1)数组的空间是连续的。 就是同类型变量的集合 (2)数组里只能存放相同类型的数据 (3)数组的下标是从0开始 (4)数组在定义的时候，必须得有一个合法空间。 int buff[]; #include int main(int argc, char * argv[]) { int buff_int[100]; //空间是多大? 400字节 //下标范围: 0~99 char buff_char[100]; //空间是多大？100字节 //下标范围:0~99 return 0; } 数组示例: #include int main(int argc, char * argv[]) { int buff1[]={1,2,3,4,5,6,7,8,9,0}; //大小以数据数量为准 int buff2[1]; //空间定义必须大于0 printf("Ú42a8d92-5935-47c5-9355-2a286c0e151en",buff1[0]); //1 printf("Ú42a8d92-5935-47c5-9355-2a286c0e151en",buff1[2]); //3 printf("Ú42a8d92-5935-47c5-9355-2a286c0e151en",buff1[4]); //5 return 0; } 数组的数据倒序输出: #include int main(int argc, char * argv[]) { int buff1[]={1,2,3,4,5,6,7,8,9,0}; //大小以数据数量为准 int i; for(i=0;i<10;i++) { printf("%d ",buff1[9-i]); } return 0; } //数组的初始化 /* 1. 数组什么时候可以整体赋值？只有在数组定义的时候 2. 数组的空间必须是常量 (C89) 错误: int data=100; int buff[data]; 3. 数组的下标是从0开始 */ 数组定义： (1)一维数组 char data[100]; (2)二维数组 char data[100][100]; (3)三维数组 char data[100][100][100]; …………. 题目: #include int main(int argc, char * argv[]) { int i; float buff[5]; //buff的名称是首地址 float sum=0; printf("输入成绩:"); for(i=0;i<5;i++) { scanf("%f",&buff[i]); } for(i=0;i<5;i++) { sum+=buff[i]; } printf("sum=ú42a8d92-5935-47c5-9355-2a286c0e151en",sum/5); return 0; }5. *号显示中文6. 显示中文 通过*号打印出自己的名字。 #include int main(int argc, char * argv[]) { unsigned char buff[]={0x08,0x08,0x7E,0x4A,0x7E,0x08,0x08,0x08}; int i,j; unsigned char data; for(i=0;i<8;i++) { data=buff[i]; for(j=0;j<8;j++) { if(data&0x80)printf("*"); else printf(" "); data<<=1; //依次判断高位 } printf("\n"); } return 0; } /* 8*8 0000 1000 0x08 0000 1000 0x08 0111 1110 0x7E 0100 1010 0x4A 0111 1110 0x7E 0000 1000 0x08 0000 1000 0x08 0000 1000 0x08 */ 汉字显示示例代码: #include int main(int argc, char * argv[]) { unsigned char buff[]= { /*-- 文字: 中 --*/ /*-- 宋体12; 此字体下对应的点阵为：宽x高=16x16 --*/ 0x01,0x00,0x01,0x00,0x01,0x00,0x01,0x00,0x3F,0xF8,0x21,0x08,0x21,0x08,0x21,0x08, 0x21,0x08,0x21,0x08,0x3F,0xF8,0x21,0x08,0x01,0x00,0x01,0x00,0x01,0x00,0x01,0x00, }; int i,j; int cnt=0; unsigned char data; for(i=0;i<32;i++) { data=buff[i]; for(j=0;j<8;j++) { if(data&0x80)printf("*"); else printf(" "); data<<=1; //依次判断高位 cnt++; } if(cnt==16) { cnt=0; printf("\n"); } } return 0; }6. 数组的数据插入1.数组的数据插入: int a[]={1,2,3,4,5,6,7}; 在第2位数据后插入一个888 最终 int a[]={1,2,888,3,4,5,6,7}; #include int main(int argc, char * argv[]) { int buff[50]={1,2,3,4,5,6,7,8,9,10}; int addr=2; //插入的位置(以正常数字计数) int len=10; //源数组里的数据长度 int data=888; //将要插入的数据 int i; /*1. 依次将数据向后移动*/ for(i=len-1;i>=addr-1;i--) { buff[i+1]=buff[i]; } buff[addr-1]=data; //插入数据 len++; //长度加1 /*2. 打印最终的结果*/ for(i=0;i7. 数组数据的删除2.数组数据的删除 int a[]={1,2,3,4,5,6,7}; 将第2位数据删除掉 最终 int a[]={1,3,4,5,6,7}; #include int main(int argc, char * argv[]) { int buff[50]={1,2,3,4,5,6,7,8,9,10}; int addr=2; //删除的位置(以正常数字计数) int len=10; //源数组里的数据长度 int i; /*1. 向前覆盖数据*/ for(i=addr-1;i8. 数组数据排序----冒泡排序3.数组数据排序----冒泡排序 int a[]={1,2,3,4,5,6,7}; 最终 int a[]={7,6,5,4,3,2,1}; 基本排序 #include int main(int argc, char * argv[]) { //将要排序的数组 int buff[10]={12,67,34,89,54,15,90,58,66,88}; int tmp; int i,j; int len=10; //数组的长度 //排序 for(i=0;ibuff[j+1]) { tmp=buff[j]; buff[j]=buff[j+1]; buff[j+1]=tmp; } } } for(i=0;i int main(int argc, char * argv[]) { //将要排序的数组 int buff[10]={1,2,3,4,5,6,7,8,9,10}; int tmp; int i,j; int len=10; //数组的长度 int cnt=0; //排序 for(i=0;i int main(int argc, char * argv[]) { //将要排序的数组 int buff[10]={1,2,3,4,5,6,7,8,9,10}; int tmp; int i,j; int len=10; //数组的长度 int cnt=0; int flag=0; //是否需要排序的标志位 //排序 for(i=0;ibuff[j+1]) //从小到大排序 { tmp=buff[j]; buff[j]=buff[j+1]; buff[j+1]=tmp; flag=1; //标记排序一次 } cnt++; } if(flag) //上一次排过序 { flag=0; //清除标志位 } else { break; } } printf("cnt=Ú42a8d92-5935-47c5-9355-2a286c0e151en",cnt); for(i=0;i9. 数组拼接4.数组数据的拼接 int a[]={1,3,4,5,6,7}; int b[]={11,13,14,15,16,17}; 将a和b拼接到c数组里。 最终int c[]={1,3,4,5,6,7, 11,13,14,15,16,17} 示例： #include int main(int argc, char * argv[]) { int buff1[50]={1,2,3,4,5,6,7,8,9,10}; int buff2[10]={11,12,13,14,15,16,17,18,19,20}; int len1=10; //源数据长度 int len2=10; //插入的数据长度 int i; for(i=0;i10. 字符串查找与替换字符串数组有一个约定: 结尾有’\0’ char buff[]={'A','B','C','D'}; //字符数组定义 char buff[]="ABCD"; //字符串数组定义 char buff[]={'A','B','C','D','\0'}; //字符串数组定义 “” //双引号之前默认有’\0’ #include int main(int argc, char * argv[]) { char str[]="嵌入式开发"; //字符串数组--文本数据 int i=0; for(i=0;str[i]!='\0';i++){} printf("i=Ú42a8d92-5935-47c5-9355-2a286c0e151en",i); return 0; } 查找与替换 #include int main(int argc, char * argv[]) { int buff[]={123,456,123,56,567,123,567}; int cnt=0,i=0; for(i=0;i<7;i++) { if(buff[i]==123) //查找 { buff[i]=888; //替换 cnt++; } } printf("cnt=Ú42a8d92-5935-47c5-9355-2a286c0e151en",cnt); for(i=0;i<7;i++) { printf("%d ",buff[i]); } return 0; } 作业: 1.字符串排序。 “24RERFER8RTBJV” 2.字符串插入: “1234567890” 在第2个位置后面插入”ABC” 最终结果: “12ABC34567890” 3.字符串查找: “123456123abc123hbc” 查找字符串”123”的数量。 数量是3 4.字符串删除: “1234567890” 删除”456” 最终结果: “1237890” 5.字符串替换 字符串”1234567890” 将456替换为”888” 最终: “1238887890” 需要考虑3种情况

总结C语言语句的几个基本练习题，计算素数、排序、求偶数和、可逆素数、水仙花数、交换大小写、交换变量的值、位运算、语法特性等知识点。1. 输出100~200之间所有可逆素数1.输出100~200之间所有可逆素数(除了1和本身能够整除)。----练习for的控制 比如: 3 7 13 11 示例: #include int main(int argc, char * argv[]) { int i,j,k; int a,b,c; int data; for(i=100;i<200;i++) //范围 { for(j=2;j2. 输入任意3个数，按从大到小的顺序输出2.输入任意3个数，按从大到小的顺序输出--->练习if语句,了解排序原理 示例: #include int main(int argc, char * argv[]) { int a=500,b=200,c=600,tmp; if(a3. 编程计算: 123+345….99100101的值3.编程计算: 1*2*3+3*4*5….99*100*101的值 示例: #include int main(int argc, char * argv[]) { //1*2*3+3*4*5….99*100*101 int i; int sum=0; for(i=1;i<=99;i+=2) { sum+=i*(i+1)*(i+2); } printf("sum=Ô9c8298c-43bc-4287-95cd-56aa94182b9en",sum); return 0; }4. 输出0~100以内的偶数之和。4.输出0~100以内的偶数之和。 示例: #include int main(int argc, char * argv[]) { int i; int sum=0; for(i=0;i<=100;i++) { if(i%2==0) //判断偶数 { sum+=i; } } printf("sum=Ô9c8298c-43bc-4287-95cd-56aa94182b9en",sum); return 0; }5. 打印所有的水仙花数5.打印所有的水仙花数。水仙花数是3位数---个位+十位+百位立方和等于它本身 例如: 123=1*1*1+2*2*2+3*3*3 示例: #include int main(int argc, char * argv[]) { int i; int sum=0; int a,b,c; for(i=100;i<=999;i++) { a=i/100; b=i0/10; c=i/1; sum=a*a*a+b*b*b+c*c*c; //计算立方和 if(sum==i) { printf("%d ",i); } } return 0; }6. 转换大小写位作业:------处理数据都得使用二进制 1.转换大小写 (位运算完成大小写转换) 示例: #include int main(int argc, char * argv[]) { char c; printf("输入一个字符:"); scanf("%c",&c); c=c^0x20; //0b00100000 0x123 printf("Ä9c8298c-43bc-4287-95cd-56aa94182b9en",c); return 0; }7. 使用位运算交换两个变量的值2.使用位运算交换两个变量的值。(规定: 只有两个变量) 示例: (可以做加密算法) #include int main(int argc, char * argv[]) { /* 01000001 原文 ^ 01100001 密码 -------- 00100000 密文 01100001 密码 -------------- 01000001 原文 */ int a=65,b=97; a=a^b; b=a^b; a=a^b; printf("%d,Ô9c8298c-43bc-4287-95cd-56aa94182b9en",a,b); return 0; }8. 完成位运算的综合运用3.完成位运算的综合运用。 (1)定义一个int类型的变量。 (2)在int类型类型变量里存放4个字母(A B C D)。 (3)存放之后在将字母取出来打印出来。 (4) 在不影响其他数据的情况下将B改为K或者其他数据 #include int main(int argc, char * argv[]) { unsigned int data=344545; /*1. 存放数据*/ data='A'<<24; data|='B'<<16; data|='C'<<8; data|='D'<<0; /*2. 取出数据*/ printf("Ä9c8298c-43bc-4287-95cd-56aa94182b9en",data>>24); printf("Ä9c8298c-43bc-4287-95cd-56aa94182b9en",(data>>16)&0xFF); printf("Ä9c8298c-43bc-4287-95cd-56aa94182b9en",(data>>8)&0xFF); printf("Ä9c8298c-43bc-4287-95cd-56aa94182b9en",(data>>0)&0xFF); /*3. 修改数据的值*/ data&=~(0xFF<<16); //清除数据 data|='K'<<16; //赋值 /*4. 取出数据*/ printf("Ä9c8298c-43bc-4287-95cd-56aa94182b9en",data>>24); printf("Ä9c8298c-43bc-4287-95cd-56aa94182b9en",(data>>16)&0xFF); printf("Ä9c8298c-43bc-4287-95cd-56aa94182b9en",(data>>8)&0xFF); printf("Ä9c8298c-43bc-4287-95cd-56aa94182b9en",(data>>0)&0xFF); return 0; }9. 显示中文 通过*号打印出自己的名字。 1.颜色转换的例子: RGB888 RGB565 RGB66…. int data=12345; //RGB888的颜色 要求将data转为RGB565 -去掉高位 2.实际的运用 short c1=1234; //R占11~15位 G占2~7位 short c2=4567; //B占 11~15位 要求: 将以上RGB分量提取出来，存在另一个变量(16位的变量)中—RGB565 。 unsigned int data_1; //整型 4个字节 unsigned short data_2; //短整型 2个字节 unsigned long data_3; //长整型 4个字节 unsigned long long data_3; //双长整型 8个字节10. C语言的特性:C语言的特性: (1) C语言程序顺序控制语法---执行顺序是从上到下。 (2) C语言程序基本组成: 函数组成---->专用的工具包。 (3) C语言语法: 变量、常量、函数、语句、关键字 (4) C语言技术关键: 数据结构、算法 C语言的基本框架: #include //头文件--->引用 int main(int argc, char *argv[]) //主函数…..入口 { printf("hello!\n"); return 0; } 学习开始: 输入(scanf)和输出(printf)11. C语言规则约定C语言编程约定 (1)每条语句分号;结束; int data; (2), 逗号 分隔符号。比如: int a,b,c,d; (3)程序里不能出现中文符号。(, ，) (4)基本逻辑程序都是在函数内部编写{ }之间。 int main(int argc, char *argv[]) { ………………… ………………… } (5) 编写每条语句，或者变量，每换一次行都需要对齐。(距离左边距4个空格---一个TAB键的距离) (6) 编写代码时，括号要连打 基本单位 1个字节------8位------------->计算机存储只能是二进制-----------> 1kb-------------1024字节 1mb------------1024kb 数据类型----决定每一个空间的大小。 int : 整型(0,12,45565,56565)， 占4字节 char :字符类型(‘A’,’6’,’7’,’D’) ，占1字节 float: 单精度浮点类型(12.454678)， 占4字节 double:双精度浮点类型，占8字节 long :长整型 ， 占4字节 long long :双长整型 ，占8字节 怎么计算？ #include int main(int argc, char *argv[]) { printf("int=%d 字节\n",sizeof(int)); printf("char=%d 字节\n",sizeof(char)); printf("float=%d 字节\n",sizeof(float)); printf("double=%d 字节\n",sizeof(double)); return 0; } 变量语法: <数据类型> 变量的名称; Int data; 变量名字命名规则： (1)数字不能开头 (2)A~Z a~z 0~9 _ 格式化打印 printf(“格式1,格式2…..\n”,变量1,变量2……….); 格式化输入 scanf(“格式1,格式2……”,&变量1,&变量2………….); 格式: %d 整型 %c 字符类型 %f 符点类型 %s 字符串类型 %o 8进制 %x 16进制 %p 打印地址 无符号声明: unsigned 只能针对整型和字符类型有效 示例: unsigned char data2=255; 测试变量的数据存放范围: #include int main(int argc, char *argv[]) { char data1=128; //范围+127 ~ -128 unsigned char data2=256; //范围 +0 ~ +255 printf("datat1=Ô9c8298c-43bc-4287-95cd-56aa94182b9en",data1); printf("datat2=Ô9c8298c-43bc-4287-95cd-56aa94182b9en",data2); return 0; } 基本运算符 + - * \ %表示取余运算符 8%4=0 =表示赋值运算符 结合运算符: += -= *= \= 比如: a=a+b; -------->a+=b;

这篇文章介绍在Linux环境下学习C语言搭建基本的环境过程，了解基础的几个命令使用方法，了解Linux下用户权限配置，标准main函数传参方式等等。1. 准备环境目的: 嵌入式开发---开发具体的产品实物---硬件电路 核心点: 学习C语言、学习STM32、学习Linux开发+驱动开发 VM虚拟机: 虚拟一台电脑。 1.Windows 2.Linux 3.Mac os Linux环境: (1)redhat 红帽系统(开发工具: C C++ java….) (2)ubuntu 乌班图操作系统 使用命令行……………… 学习步骤 (1)学习基本命令使用 (2)学习C语言的开发2. Linux下基本操作登录账户: root 密码:根密码 打开虚拟机的方法： 终端命令操作： (1)缩小字体: Ctrl + “ - ” (2)放大字体:Ctrl+Shift +”+” 了解的基本知识 (1)Linux系统下: #表示超级用户(root) $ 表示普通用户 (2)Linux下目录: 最顶层的目录--- / (3)Linux下看帮助的一些约定: [ ] 表示参数选填 < > 表示参数必须填 3. 介绍基本的命令使用1.ls命令: 列出指定目录下的所有的文件 命令的使用方法: ls [参数] (1)-l 表示看详细信息 (2)-a 表示看隐藏文件 (3)路径: 比如: ls /work 2.cd 命令: 切换目录 命令的使用方法: cd [切换的目录路径] 约定的路径表示方法: (1)./ : 表示当前路径 (2)../ :表示上一层路径(父目录) 想要表示上上层: ../../ (3)~ : 表示用户目录 (默认cd不带参数，就是~) (4)- : 表示回到上一次的目录 切换目录示例: cd /work/pwd 相对路径和绝对路径区别: 相对路径就是相对当前的目录路径进行寻址 绝对路径就是从根目录下进行寻址。 3.clear 命令: 清除屏幕的一页 (实际上是翻页) 4.pwd 命令: 获取当前目录的绝对路径 5.rm 命令: 文件和文件夹删除命令 用法: rm <文件或者文件夹的名称> [参数] 参数: -f :表示强制删除 -v :输出删除的过程 -r :表示删除的是目录 示例: # rm 123 -rfv 强制删除并输出过程 通配符号: * 所有 #rm ./星 -rf 强制删除当前目录下的所有文件。 6.mkdir 命令: 创建目录 用法: mkdir <创建的目录名称> [参数] 参数: -p :可以一次性创建多层目录 示例: # mkdir 123/456/abc/bhu -p 一次创建多层目录 7.vim 命令: 基于命令行的编辑器 用法: vim <文件名称> //如果文件不存在就创建， 存在就打开 vim 有两种模式: 命令模式 和文本模式 (1)进入到命令模式的方法: Ctrl + “:” 在命令模式常用的操作: w保存 q退出 wq 保存并退出 q!不保存强制退出 (2)退出命令模式： ESC (3)进入文本编辑模式: i表示插入数据， 退出:ESC 8.gedit 文本编辑器(记事本) 用法: gedit 123.c 9.gcc 编译器 用法: gcc <将要编译的文件> [参数] 常用参数: -o 指定编译之后生成的文件名称 比如: gcc 123.c -o app 支持编译多个文件: gcc 123.c 456.c ….. -o app 10.man 命令: 查看帮助 用法: man [页码1~7] <函数、头文件、命令> 例如: #man ls #man 3 printf 进入到帮助页面之后, q就直接退出 修改vim文件的配置: 加入行号显示。 # vim /etc/vimrc 在文件最后加上两行代码，保存退出: set number set tabstop=4 切换到超级用户: $su root 然后输入密码 按下回车确认 退出编辑器界面: 输入q! linux下快捷方式 多使用: Tab按键 介绍: 在命令行下自动补全 多使用方向上下箭头 介绍: 查看历史命令 空格在Linux下很特殊，空格用来作为分隔符。 所以: 文件名称 目录的名称 就不能包含空格。4. C语言基础4.1 main函数练习: 创建一个C语言文件，编译，再输出。 C语言基本构造: 前期主要学习 流程控制 (1)C语言代码是由函数组成。 (2)学习基本语法 (3)学习语法的组合运行 1 #include //头文件 2 int main() //主函数,C语言程序的入口。 3 { 4 printf("hello world!\n"); //格式化打印函数，向控制台的标准输出打印数据 5 return 0; //返回命令 0表示返回的数据 6 } # : 表示预编译，替换 存储的基本单位: 1个字节 = 8位 ---->二进制 --->电平 3---->0x3--->0000 00114.2 数据类型数据类型 1.int 整型 占4个字节 2.char 字符类型 占1个字节 3.float 单精度浮点，占4个字节 4.double 双精度浮点类型，占8个字节 C语言变量定义语法 <数据类型> <变量的名称>; int a; 1个字节=8位 1111 1111 ---->255 C语言有变量和常量之分: 变量可以改变数据 常量不能改变 int a=56; 784.3 格式打印与输入格式化打印 printf("c=Ñ5afb7f4-001e-4d7b-9bcd-32bf4b308ef3n",c); 用法: int data=888; printf(“%d”,data); 说明: 双引号之间的数据都会原样打印。 格式: %d :整型 %c :字符 %f : 浮点数 %s :表示字符串 int data=888; printf(“data=%d”,data); //输出的结果:data=888 想要输出多个数据: printf(“data1=%d,data2=%d”,123,456); 格式化输入函数 示例: int data; scanf(“%d”,&data); 表示从键盘上输入一个整数存放到data变量中。 &:取地址，得到变量在计算机里的地址。 怎么结束? 空格最为结束分隔符、回车键结束输入 1.#include 2 int main() 3 { 4 int data; 5 printf("请输入整数:"); 6 scanf("%d",&data); 7 printf("data=Ñ5afb7f4-001e-4d7b-9bcd-32bf4b308ef3n",data); 8 return 0; 9 } 输入字符： 1 #include 2 int main() 3 { 4 char c='B'; //单引号 5 printf("c=Ñ5afb7f4-001e-4d7b-9bcd-32bf4b308ef3n",c); 6 return 0; 7 } 作业 1.实现大小写转换。 (1)从键盘上输入一个大写字母，输出小写字母 (2)从键盘上输入一个小写字母，输出大写字母 实际的案例：验证码 2. (1) 验证char类型变量最大可以存放多大数据 (2) 验证int类型变量最大可以存放多大数据 char data=88; 在浏览器输入: 192.168.1.130:8080 作业: 1.搭建虚拟环境: 重新安装一次操作系统 http://bbs.wanbangee.com/bbs/forum.php 2.熟悉系统操作命令 3.学习C语言基本语法

1. 前言WebAssembly/wasm WebAssembly 或者 wasm 是一个可移植、体积小、加载快并且兼容 Web 的全新格式。WebAssembly的名字带个汇编Assembly，所以我们从其名字上就能知道其意思是给Web使用的汇编语言，是通过Web执行低级二进制语法。但是WebAssembly并不是直接用汇编语言，而提供了抓换机制（LLVM IR），把高级别的语言（C，C++和Rust）编译为WebAssembly，以便有机会在浏览器中运行。主要是解决目前JS语言的效率问题，设计立足点为快速，内存安全和开放。所以是一种运行机制，一种新的字节码格式(.wasm)官网介绍: cid:link_12. 安装ubuntu 20.04ubuntu20.04 安装emcc编译最方便，只需要简单的几个命令即可完成。镜像下载地址: cid:link_0 下载之后，安装系统。我这里使用VMware Workstation Pro 15.5 虚拟机安装系统。安装的过程就不多说了，常规步骤，都比较简单。系统安装完毕之后需要安装vmtools工具才可以放大自适应桌面，访问共享目录，支持复制粘贴。 如果在下拉菜单里，安装vm tools工具的按钮是灰色的，需要将CD挂载选项，改成自动检测，然后关闭系统，关闭虚拟机，重新再打开，再启动系统，再次打开下拉菜单，就可以选择工具安装了。 将弹出的压缩包拷贝出来，解压，运行里面的脚本，然后一直回车确认，最后就可以安装完成。 注意: 安装过程中有no 这种选项的时候要注意，要输入yes，在按下回车，不然就直接结束安装了。 3. ubuntu 20.04安装emcc编译器安装emcc编译器之前需要安装python，ubuntu20.04 系统安装之后，系统默认是安装了python 的， 这个就不用管了。emcc编译器的代码在GitHub仓库里，需要安装Git工具，这个系统没自动安装，需要自己安装。wbyq@wbyq:~/work_pc/WebAssembly/emsdk$ sudo apt install git编译代码需要用到make命令，make也没有安装，需要手动安装。 安装之后，就可以继续下面的步骤了。（1）创建工作目录，存放接下来下载的相关文件xl@xl:~/work$ mkdir wasm xl@xl:~/work$ cd wasm/（2）从仓库克隆项目xl@xl:~/work/wasm$ git clone https://github.com/emscripten-core/emsdk.git 正克隆到 'emsdk'... remote: Enumerating objects: 3138, done. remote: Total 3138 (delta 0), reused 0 (delta 0), pack-reused 3138 接收对象中: 100% (3138/3138), 1.66 MiB | 174.00 KiB/s, 完成. 处理 delta 中: 100% (2043/2043), 完成. wbyq@wbyq:~/work_pc/WebAssembly$ ls emsdk wbyq@wbyq:~/work_pc/WebAssembly$ cd emsdk/ wbyq@wbyq:~/work_pc/WebAssembly/emsdk$ ls bazel emscripten-releases-tags.json emsdk_env.bat emsdk_env.ps1 emsdk.ps1 legacy-emscripten-tags.txt README.md docker emsdk emsdk_env.csh emsdk_env.sh emsdk.py LICENSE scripts emcmdprompt.bat emsdk.bat emsdk_env.fish emsdk_manifest.json legacy-binaryen-tags.txt llvm-tags-64bit.txt test（3）安装最新的编译器wbyq@wbyq:~/work/wasm/emsdk$ ./emsdk install latest Resolving SDK alias 'latest' to '3.1.4' Resolving SDK version '3.1.4' to 'sdk-releases-upstream-39e60dda6945cfcd6487725bdb1361ae7975173f-64bit' Installing SDK 'sdk-releases-upstream-39e60dda6945cfcd6487725bdb1361ae7975173f-64bit'.. Installing tool 'node-14.18.2-64bit'..等待片刻，即可全部下载完成。 （4）激活SDKxl@xl:~/work/wasm/emsdk$ ./emsdk activate latest（5）生效环境变量xl@xl:~/work/wasm/emsdk$ source emsdk_env.sh（6）查看编译器版本详细信息该命令只能在当前终端生效，可以将命令加到etc/profile里，重启系统全局生效。 4. 编写C/C++代码测试下面编写一个C语言代码，导出函数接口，给前端JS调用测试。（1）编写简单的C代码，提供1个测试函数#include #include #include #include int func_sum(int x, int y) { return x + y; }（2）编译测试emcc app.c -o app.js -s EXPORTED_FUNCTIONS="['_func_sum','_malloc','_free']" -s WASM=1EXPORTED_FUNCTIONS 里填写可以导出给js调用的函数接口。（3）编译成功生成app.js和app.wasm （4）编写一个HTML文件。名称设置为: index.html wasm test（5）启动HTTP服务器python3 -m http.server（6）打开浏览器访问按下F12，查看控制台的输出。http://127.0.0.1:8000/index.html5. 编译ffmpeg（1）下载ffmpeg源码 切换分支到4.1 git clone https://git.ffmpeg.org/ffmpeg.git cd ffmpeg git checkout -b 4.1 origin/release/4.1（2）编译emconfigure ./configure --cc="emcc" --enable-cross-compile --target-os=none --arch=x86_32 --cpu=generic --disable-ffplay --disable-ffprobe --disable-asm --disable-doc --disable-devices --disable-pthreads --disable-w32threads --disable-network --disable-hwaccels --disable-parsers --disable-bsfs --disable-debug --disable-protocols --disable-indevs --disable-outdevs --enable-protocol=file（3）编写C代码，测试ffmpeg解码，编译emcc app.c ffmpeg-4.4-wasm/lib/libavformat.a ffmpeg-4.4-wasm/lib/libavcodec.a ffmpeg-4.4-wasm/lib/libswresample.a ffmpeg-4.4-wasm/lib/libavutil.a -I "ffmpeg-4.4-wasm/include" -s EXPORTED_FUNCTIONS="['_malloc','_free','ccall','allocate','UTF8ToString','_write_file','_print_version','_get_FileSize','_read_file','_GetVideoFrame','_GetVideoWidth','_GetVideoDuration','_GetVideoHeight','_DeleteMemory','_find_Decoder']" -s WASM=1 -s ASSERTIONS=0 -s TOTAL_MEMORY=167772160 -s ALLOW_MEMORY_GROWTH=1 -o out/ffmpeg_decoder.js（4）开启服务器python -m http.server（5）调用测试ffmpeg

C语言字符串全方位练习，涉及知识点：字符串解析、大小写判断、字符串插入、字符串删除、字符串排序、字符串转整数、字符串转浮点数、时间转换、GPS数据解析等等。1. 计算空格、大小写字母从键盘上输入一个字符串, 计算字符串里有多少个空格、小写字母、大写字母、数字。#include //标准输入输出 #include //字符串处理头文件 int main(int argc,char **argv) { int len=0; int i; char str[100]; int cnt[5]={0}; //初始化赋值 //scanf("%s",str); //从键盘上录入字符串,字符串结尾: '\0' //gets(str); //从键盘上录入字符串 fgets(str,100,stdin); //从键盘上录入字符串 (标准输入) //空格、小写字母、大写字母、数字 其他数据 /*1. 计算字符串的长度*/ while(str[len]!='\0')len++; printf("len1=Ü053fd8d-61e9-42c7-a40b-f8d94b525ea8n",len); printf("len2=Ü053fd8d-61e9-42c7-a40b-f8d94b525ea8n",strlen(str)); //计算字符串长度 /*2. 处理字符串*/ for(i=0;i='a'&&str[i]<='z')cnt[1]++; else if(str[i]>='A'&&str[i]<='Z')cnt[2]++; else if(str[i]>='0'&&str[i]<='9')cnt[3]++; else cnt[4]++; } /*3. 打印结果*/ printf("空格:Ü053fd8d-61e9-42c7-a40b-f8d94b525ea8n",cnt[0]); printf("小写:Ü053fd8d-61e9-42c7-a40b-f8d94b525ea8n",cnt[1]); printf("大写:Ü053fd8d-61e9-42c7-a40b-f8d94b525ea8n",cnt[2]); printf("数字:Ü053fd8d-61e9-42c7-a40b-f8d94b525ea8n",cnt[3]); printf("其他:Ü053fd8d-61e9-42c7-a40b-f8d94b525ea8n",cnt[4]); return 0; }2. 字符串排序示例: #include //标准输入输出 #include //字符串处理头文件 int main(int argc,char **argv) { int len=0; int i,j; char tmp; char str[100]; fgets(str,100,stdin); //从键盘上录入字符串 (标准输入) /*1. 计算字符串的长度*/ len=strlen(str); //计算字符串长度 /*2. 字符串排序*/ for(i=0;i3. 字符串插入字符串插入: “1234567890” 在第2个位置后面插入”ABC” 最终结果: “12ABC34567890”#include //标准输入输出 #include //字符串处理头文件 int main(int argc,char **argv) { int i,j; int src_len; int new_len; /* 123456789 12 3456789 */ char src_str[100]="123456789"; char new_str[]="abcd"; int addr=2; //插入的位置 /*1. 计算字符串的长度*/ src_len=strlen(src_str); //"123" new_len=strlen(new_str); /*2. 字符串移动*/ for(i=src_len-1;i>addr-1;i--) { src_str[i+new_len]=src_str[i]; //向后移动 new_len } /*3. 插入新的数据*/ for(i=0;i4. 字符串查找字符串查找: “123456123abc123hbc” 查找字符串”123”的数量。数量是3#include //标准输入输出 #include //字符串处理头文件 int main(int argc,char **argv) { char src_str[100]; char find_str[10]; int src_len=0,find_len=0; int i,j; int cnt=0; /*1. 录入字符串*/ printf("输入源字符串:"); //123dufvdfv123dfljvb fgets(src_str,100,stdin); //从键盘上录入源字符串 //scanf("%s",src_str); printf("输入查找的字符串:"); //123 fgets(find_str,10,stdin); //从键盘上录入源字符串 //scanf("%s",find_str); /*2. 计算长度*/ src_len=strlen(src_str); src_str[src_len-1]='\0'; src_len-=1; //src_len=src_len-1; find_len=strlen(find_str); //"123\n" =4 find_str[find_len-1]='\0'; find_len-=1; printf("源字符串:%s,Ü053fd8d-61e9-42c7-a40b-f8d94b525ea8n",src_str,src_len); printf("查找的字符串:%s,Ü053fd8d-61e9-42c7-a40b-f8d94b525ea8n",find_str,find_len); /*3. 查找字符串*/ for(i=0;i5. 字符串删除字符串删除: “1234567890” 删除”456” 最终结果: “1237890”示例: #include //标准输入输出 #include //字符串处理头文件 int main(int argc,char **argv) { char src_str[100]; char del_str[10]; int src_len=0,del_len=0; int i,j; int cnt=0; /*1. 录入字符串*/ printf("输入源字符串:"); //123dufvdfv123dfljvb fgets(src_str,100,stdin); //从键盘上录入源字符串 printf("输入查找的字符串:"); //123 fgets(del_str,10,stdin); //从键盘上录入源字符串 /*2. 计算长度*/ src_len=strlen(src_str); src_str[src_len-1]='\0'; src_len-=1; //src_len=src_len-1; del_len=strlen(del_str); //"123\n" =4 del_str[del_len-1]='\0'; del_len-=1; printf("源字符串:%s,Ü053fd8d-61e9-42c7-a40b-f8d94b525ea8n",src_str,src_len); printf("删除字符串:%s,Ü053fd8d-61e9-42c7-a40b-f8d94b525ea8n",del_str,del_len); /*3. 查找*/ for(i=0;i6. 字符串替换字符串”1234567890” 将456替换为”888” 最终: “1238887890” 需要考虑3种情况7. 字符串转整数。从键盘上输入一个字符串”12345”, 得到整数: 12345;#include //标准输入输出 #include //字符串处理头文件 int string_to_int(char str[]); int main(int argc,char **argv) { int data; char str[]="125abcd"; data=string_to_int(str); printf("data=Ü053fd8d-61e9-42c7-a40b-f8d94b525ea8n",data); return 0; } /* 函数功能: 字符串转为整数 字符转为整数: -48 或者 -'0' 1234 */ int string_to_int(char str[]) { int value=0; //存放转换之后的结果 int i=0; while((str[i]!='\0')&&(str[i]>='0'&&str[i]<='9')) { value*=10; value+=str[i]-'0'; i++; } return value; }8. 整数转字符串整数转字符串。输入一个整数1234，得到字符串: "1234"1234=4 1234/10=123 123=3 123/10=12 示例: #include //标准输入输出 #include //字符串处理头文件 void int_to_string(char str[],int data); int main(int argc,char **argv) { char str[100]; int_to_string(str,12345); printf("str=%s\n",str); return 0; } /* 函数功能: 整数转为字符串 函数参数: char str[] //存放转换之后的整数(字符串) int data //待转换的整数 */ void int_to_string(char str[],int data) { int i=0,j; char tmp; /*1. 将整数转为字符串*/ while(data) { str[i]=data+'0'; data/=10; i++; } str[i]='\0'; /*2. 交换顺序*/ for(j=0;j9. 浮点数转字符串浮点数转字符串。输入一个浮点数123.456 得到字符串"123.456"示例: #include //标准输入输出 #include //字符串处理头文件 void float_to_string(char str[],float data); int main(int argc,char **argv) { char str[100]; float_to_string(str,12345.123); printf("str=%s\n",str); return 0; } /* 函数功能: 浮点数转为字符串 函数参数: char str[] //存放转换之后的 浮点数(字符串) int data //待转换的 浮点数 */ void float_to_string(char str[],float data) { int i=0,j; char tmp; int addr; int int_data=data; //得到整数 12345 int float_data=(data-int_data)*1000000;// 0.123456 *1000000 =123456 /*1. 将整数部分转为字符串*/ while(int_data) { str[i]=int_data+'0'; int_data/=10; i++; } str[i]='.'; //添加小数点 /*2. 交换顺序: 整数*/ for(j=0;j10.字符串转浮点数字符串转浮点数。输入一个字符串: "123.456" 得到浮点数类型: 123.456#include //标准输入输出 #include //字符串处理头文件 float string_to_float(char str[]); int main(int argc,char **argv) { float data; char str[]="123.456"; data=string_to_float(str); printf("data=ü053fd8d-61e9-42c7-a40b-f8d94b525ea8n",data); return 0; } /* 函数功能: 字符串转为浮点数 字符转为整数: -48 或者 -'0' */ float string_to_float(char str[]) { int int_value=0; //存放转换之后的结果 int float_value=0; int i=0; float data; int cnt=0; //记录小数部分的数量 int tmp=1; /*1. 整数部分*/ while((str[i]!='\0')&&(str[i]>='0'&&str[i]<='9')) { int_value*=10; int_value+=str[i]-'0'; i++; } /*2. 浮点数部分*/ i++; //跨过小数点 while((str[i]!='\0')&&(str[i]>='0'&&str[i]<='9')) { float_value*=10; float_value+=str[i]-'0'; i++; cnt++; } for(i=0;i11. 时间转换时间转换(秒与标准时间的转换)。 在代码里加入: #include 头文件。‘ 调用time_t time(time_t *t);函数获取本地时间。 示例: unsigned int sec=time(NULL); //sec是获取到的秒单位时间 该时间是从1970年开始计算的。 什么是标准时间？ 得到年-月-日 时:分:秒 本身: 数字电子钟。 RTC: 实时时钟。#include time_t time(time_t *t); Linux下日期修改: [root@wbyq code]# date -s "2018-12-24 21:09:20" 示例: #include //标准输入输出 #include //字符串处理头文件 #include int get_year(int year); void sec_to_time(int sec); void Get_Week(int sec); //定义时间结构 int tm_sec; /* seconds */ int tm_min; /* minutes */ int tm_hour; /* hours */ int tm_mday; /* day of the month */ int tm_mon; /* month */ int tm_year; /* year */ int tm_wday; /* day of the week */ int tm_yday; /* day in the year */ int mon_p[12]={31,28,31,30,31,30,31,31,30,31,30,31}; int mon_r[12]={31,29,31,30,31,30,31,31,30,31,30,31}; int main(int argc,char **argv) { int sec1; int sec2; while(1) { sec1=time(NULL);//获取当前计算机系统的秒单位时间 if(sec1!=sec2) { sec2=sec1; sec_to_time(sec2+8*60*60); printf("%d-%d-%d %d:%d:Ü053fd8d-61e9-42c7-a40b-f8d94b525ea8n", tm_year, tm_mon, tm_mday, tm_hour, tm_min, tm_sec ); printf("当前时间是当前年的第%d天\n",tm_yday); } } return 0; } /* 函数功能: 秒转标准时间 */ void sec_to_time(int sec) { int i; Get_Week(sec); /*1. 得到年份*/ tm_year=1970;//基础年份 while(sec>=365*24*60*60) { if(get_year(tm_year)) //闰年 { if(sec>=366*24*60*60) { sec-=366*24*60*60; //减去一年 tm_year++; //增加一年 } else break; } else //平年 { sec-=365*24*60*60; //减去一年 tm_year++; //增加一年 } } /*计算当前时间是一年中的第几天*/ tm_yday=sec/(24*60*60); /*2. 得到月份*/ tm_mon=1; for(i=0;i<12;i++) { if(get_year(tm_year)) //闰年 { if(sec>=mon_r[i]*24*60*60) { sec-=mon_r[i]*24*60*60; tm_mon++; } else break; } else //平年 { if(sec>=mon_p[i]*24*60*60) { sec-=mon_p[i]*24*60*60; tm_mon++; } else break; } } /*3. 天数*/ tm_mday=1; while(sec>=24*60*60) { tm_mday++; sec-=24*60*60; } /*4. 小时*/ tm_hour=0; while(sec>=60*60) { tm_hour++; sec-=60*60; } /*5. 分钟*/ tm_min=0; while(sec>=60) { tm_min++; sec-=60; } /*6. 秒*/ tm_sec=sec; } /* 函数功能: 获取年份状态: 平年和闰年 函数参数: year填年份 返回值: 0表示平年 1表示闰年 */ int get_year(int year) { if((year@0==0)||(year%4==0&&year0!=0)) { return 1; } return 0; } /* 函数功能: 获取星期 */ void Get_Week(int sec) { int day=sec/(24*60*60); switch(day%7) { case 0: printf("星期4\n"); break; case 1: printf("星期5\n"); break; case 2: printf("星期6\n"); break; case 3: printf("星期日\n"); break; case 4: printf("星期1\n"); break; case 5: printf("星期2\n"); break; case 6: printf("星期3\n"); break; } }12. GPS数据解析提取最基本的数据： (1) UTC时间 (2) 海拔高度 (3) 经纬度 //GPS返回的数据格式如下 char gps_data[]= { "$GNGGA,114955.000,2842.4158,N,11549.5439,E,1,05,3.8,54.8,M,0.0,M,,*4F \ $GNGLL,2842.4158,N,11549.5439,E,114955.000,A,A*4D \ $GPGSA,A,3,10,31,18,,,,,,,,,,5.7,3.8,4.2*37 \ $BDGSA,A,3,07,10,,,,,,,,,,,5.7,3.8,4.2*2A \ $GPGSV,3,1,10,10,49,184,42,12,16,039,,14,54,341,,18,22,165,23*7B \ $GPGSV,3,2,10,22,11,318,,25,51,055,,26,24,205,,29,13,110,*7C \ $GPGSV,3,3,10,31,50,287,36,32,66,018,*7F \ $BDGSV,1,1,04,03,,,07,05,,,29,07,79,246,33,10,52,232,19*62 \ $GNRMC,114955.000,A,2842.4158,N,11549.5439,E,0.00,44.25,061117,,,A*4D \ $GNVTG,44.25,T,,M,0.00,N,0.00,K,A*14 \ $GNZDA,114955.000,06,11,2017,00,00*47 \ $GPTXT,01,01,01,ANTENNA OK*35" };

在使用amct时报错amct_acl: cannot execute binary file

字符串函数重写练习：字符串比较、字符串拼接、字符串查找、字符串拷贝、内存比较、内存拷贝、内存初始化、内存比较、二维数组定义及基本使用、位运算练习--通过取模打印中文字模在控制台。1. memcpy内存拷贝#include //标准输入输出 #include //字符串处理头文件 int main(int argc,char **argv) { char str1[]="1234567"; char str2[100]; memcpy(str2,str1,sizeof(str1)); //将str1里数据拷贝到str2 printf("str2=%s\n",str2); int buff1[]={12,34,56,78,90}; int buff2[100]; memcpy(buff2,buff1,sizeof(buff1)); int i; for(i=0;i2. memcmp内存比较#include //标准输入输出 #include //字符串处理头文件 int main(int argc,char **argv) { char str1[]="123456789"; char str2[]="1234"; //相等返回值是0 printf("Ò262b9a4-7f2e-463b-8efc-1d42cdfe330bn",memcmp(str1,str2,4)); return 0; }3. memset函数: 初始化内存空间#include //标准输入输出 #include //字符串处理头文件 int main(int argc,char **argv) { char str[20]="123456789"; //将数组空间str全部置为0 //该函数存在的意义: 用在做数组的初始化 memset(str,0,20); printf("str=%s\n",str); int data[100]; memset(data,0,sizeof(data)); return 0; }4. 字符串拼接函数: strcat#include //标准输入输出 #include //字符串处理头文件 int main(int argc,char **argv) { char str1[100]="12345"; char str2[100]="67890"; strcat(str1,str2); //字符串拼接 printf("%s\n",str1); return 0; }5. 字符串比较：strcmp#include //标准输入输出 #include //字符串处理头文件 int main(int argc,char **argv) { char str1[100]="12345"; char str2[100]="12345"; //相等返回0,其他值不相等 printf("状态=Ò262b9a4-7f2e-463b-8efc-1d42cdfe330bn",strcmp(str1,str2)); return 0; }6. 字符串拷贝函数: strcpy#include //标准输入输出 #include //字符串处理头文件 int main(int argc,char **argv) { char str1[100]="12345"; char str2[100]="67890"; //将str2数据拷贝到str1，覆盖原来的数据 strcpy(str1,str2); printf("%s\n",str1); return 0; }7. 字符串拼接: (安全性更加高)strncat#include //标准输入输出 #include //字符串处理头文件 int main(int argc,char **argv) { char str1[10]="12345"; char str2[]="abcdefg67890"; //strcat(str1,str2); //拼接 //printf("%s\n",str1); strncat(str1,str2,5); printf("%s\n",str1); return 0; }8. 字符串查找: strstrStrstr函数成功查找到字符串将会返回该字符串在数组里的地址。 #include //标准输入输出 #include //字符串处理头文件 int main(int argc,char **argv) { char str[]="abcd123dlfvndflvb123"; printf("str首地址:%p\n",str); char *p=strstr(str,"456"); if(p==(void*)0)printf("字符串查找失败!\n"); //if(p==NULL)printf("字符串查找失败!\n"); printf("查找的地址:%p\n",p); printf("%s\n",p); //123dlfvndflvb123 return 0; }9. 内存拷贝: memcpy/* 内存拷贝函数,内部按照字节拷贝 */ void *my_memcpy(void *str1, const void *str2, int size) { char *p1=str1; const char *p2=str2; int i; for(i=0;i10. 内存比较: memcmp/* 相等返回:0 不相等:1 */ int my_memcmp(const void *str1, const void *str2,int size) { const char *p1=str1; const char *p2=str2; int i; for(i=0;i11. 内存空间赋值: memsetvoid *my_memset(void *str,int data,int size) { char *p=str; int i; for(i=0;i12. 字符串查找: strstr示例代码： 分析地址 #include //标准输入输出 #include //字符串处理头文件 /* char *strstr(const char *str1, const char *str2); 功能: 在str1字符串里查找str2字符串首次出现的位置。 查找成功就返回查找的地址 */ int main(int argc,char **argv) { char a=100; a=50; char *p; p=&a; //p=0xbf939fac; printf("%p\n",&a); // &a==0xbf939fac a==100 printf("%p\n",p); *p=10; //将10赋值给p指向的空间 printf("a=Ò262b9a4-7f2e-463b-8efc-1d42cdfe330bn",a); return 0; } //xxx实验室 //xx栋xxx层xxx间 示例代码: 地址概念讲解 #include //标准输入输出 #include //字符串处理头文件 int main(int argc,char **argv) { int a=100; printf("a=Ò262b9a4-7f2e-463b-8efc-1d42cdfe330bn",a); printf("地址=%p\n",&a); unsigned int b=0; printf("请输入地址:"); scanf("%x",&b); printf("输入的地址=0x%x\n",b); *(int*)b=200; // 等价于 *(int*)0xbf82102c printf("a的值=Ò262b9a4-7f2e-463b-8efc-1d42cdfe330bn",a); return 0; } #include //标准输入输出 #include //字符串处理头文件 char *my_strstr(const char *str1, const char *str2); int main(int argc,char **argv) { char str[]="abcd123dlfvndflvb123"; printf("str首地址:%p\n",str); char *p=my_strstr(str,"123"); if(p==NULL)printf("字符串查找失败!\n"); printf("查找的地址:%p\n",p); printf("%s\n",p); //123dlfvndflvb123 return 0; } //"sdjcb123dfkv" char *my_strstr(const char *str1, const char *str2) { int len1=strlen(str1); int len2=strlen(str2); int i,j; if(len113. 二维数组定义多维数组: int data[][][]…….; 使用最多的: 一维数组和二维数组。 int data1[10]; //定义一维数组 int data2[10][10];//定义二维数组 //int data2[行][列]; 定义二维数组时，行可以不填，列必须填。 示例代码：二维数组使用 #include int main(int argc,char**argv) { int data1[10]={1,2,3,4,5,6,7,8,9,0}; //定义一维数组 int data2[10][10]= { {1,2,3,4,5,6,7,8,9,0}, {1,2,3,4,5,6,7,8,9,0}, {1,2,3,4,5,6,7,8,9,0}, }; //data1[0]; //访问数组下标第一个元素数据 //data2[0]; //表示第一个一维数组首地址 int i,j; for(i=0;i<10;i++) { for(j=0;j<10;j++) { printf("%d",data2[i][j]); //data2[0~9][0~9] } printf("\n"); } return 0; } 示例代码: 二维数组 #include int main(int argc,char**argv) { char buff[][10]= { {"12345"}, {"45678"}, }; printf("%s\n",buff[0]); //buff[0]:表示一维数组的首地址 printf("%s\n",buff[1]); //buff[1]:表示一维数组的首地址 printf("sizeof=Ò262b9a4-7f2e-463b-8efc-1d42cdfe330bn",sizeof(buff)); return 0; } 示例代码： 多维数组 #include int main(int argc,char**argv) { int data[10][10][10][10]= { { { { 12,34,56,78,90 } } } }; printf("Ò262b9a4-7f2e-463b-8efc-1d42cdfe330bn",data[0][0][0][3]); //78 return 0; }14. 使用*号在屏幕上打印出中文或者数据数据。#include /* 取模方式: 1. 高位在前 2. 横向取模 （是8的倍数） */ unsigned char font[]= { /*-- 文字: 中 --*/ /*-- 幼圆12; 此字体下对应的点阵为：宽x高=16x16 --*/ 0x00,0x00,0x01,0x80,0x01,0x80,0x01,0x80,0x7F,0xFE,0x61,0x86,0x61,0x86,0x61,0x86, 0x61,0x86,0x61,0x86,0x61,0x86,0x7F,0xFE,0x01,0x80,0x01,0x80,0x01,0x80,0x01,0x80, }; int main(int argc,char**argv) { int i,j; int x=0; unsigned char tmp; for(i=0;i<16*16/8;i++) { tmp=font[i]; //取出一个字节 //按位判断 for(j=0;j<8;j++) { if(tmp&0x80)printf("*"); else printf(" "); tmp<<=1; //向左移动一位，持续判断高位 x++; } if(x==16) { printf("\n"); x=0; } } return 0; }

当前文章复盘C语言的： 位运算运算符、基本运算符、数据类型、变量、for语句、while语句、goto语句、switch语句、运算符优先级强制转换等。一、变量的命名变量的命名: (13个字符) 1. A~Z a~z 2. 0-9 3. _ 4. 说明: 只能字母和数字开头。不能使用关键字。 //左值和右值 unsigned int a=123; //4个字节 const int b=456; char c='A'; float d=123.456; //123.456 浮点数常量 char *p="123456"; //"123456"字符串常量二、常量数据格式#include "stdio.h" //常量声明: U和L 表示无符号长整型 #define ABC 123UL #define ABC 123ul int main(void) { //0b101010; //二进制表示形式 //0x123; //表示十六进制 //123 //表示十进制 int a=0x123; return 0; }三、运算符3.1 逻辑非#include "stdio.h" //常量声明: U和L 表示无符号长整型 #define ABC 123UL int main(void) { int a=0; if(!a) { printf("为真!\n"); } int data=1234; printf("Ò57dcc71-9896-422b-ae91-6c30ec91dcc8n",!!data); //1 return 0; }3.2 位运算& ：全1为1，有0为0 | ：全0为0，有1为1 ^ ：相同为0，不同为1 ~ ：1为0，0位1 >> ：右移运算，低位溢出高位补0 << ：左移运算符，高位溢出，低位补0位运算符使用较多的地方: (1) 单片机里寄存器操作(2) 协议加密解密、压缩算法、各种算法。(3) 当做标志位使用#include "stdio.h" //系统里需要有8个状态位，需要存放8个状态位--------当做寄存器使用 int main(void) { unsigned char a=0; //8个位 范围:0~7 //如何将a第7位,置1呢? a|=1<<7; //如何将a第2位,置1呢? a|=1<<2; //将2的第3位和第4位置1 a|=0x3<<3; //如何判断第7位是0还是1呢？ if((a>>7)&0x1) { printf("第7位的值为真!\n"); } else { printf("第7位的值为假!\n"); } //bool sbit 位定义 。 //bool a; sbit LED1=P1^1; return 0; }3.3 sizeof运算符Sizeof运算符 #include "stdio.h" int main(void) { int a=1234; printf("Ò57dcc71-9896-422b-ae91-6c30ec91dcc8n",sizeof(a)); //4 int b=1; printf("Ò57dcc71-9896-422b-ae91-6c30ec91dcc8n",sizeof(b)); //4 return 0; }3.4 三目运算符#include "stdio.h" int main(void) { /* int a; scanf("%d",&a); //取地址 int a,b; a=a&b; //与 int a,b; a=a*b; //乘号 int *a; //指针类型 */ int a; a=8>5?123:456; //if(8>5){a=123;}else{a=456;} printf("Ò57dcc71-9896-422b-ae91-6c30ec91dcc8n",a); //123 return 0; }3.5 运算符的优先级和强制转换#include "stdio.h" int main(void) { int a=123+456-12*5/78; //高优先级先结合，再依次.... //如果优先级同级，执行顺序是从左边到右边。 //优先级最高:()小括号 int b=123456789; char a=(char)b; //强制转换,只是取低8位 //欺骗编译器，告诉它，b是char类型。 char a='8'; int b=(int)a; //强制转换 printf("b=Ò57dcc71-9896-422b-ae91-6c30ec91dcc8n",b); //还是字符8 return 0; }四、语句4.1 for循环语句#include "stdio.h" //系统里需要有8个状态位，需要存放8个状态位--------当做寄存器使用 int main(void) { int a=123,b=456; int cnt=0; for(a=0;a<5;a++) { for(b=0;b<5;b++) { if(a==2) { break; //跳出最近的一层循环 } cnt++; } } /* for(;;) { //死循环 } while(1) { //死循环 } do { //死循环 }while(1); */ printf("cnt=Ò57dcc71-9896-422b-ae91-6c30ec91dcc8n",cnt);//20 return 0; }4.2 while循环语句while循环语句 #include "stdio.h" //系统里需要有8个状态位，需要存放8个状态位--------当做寄存器使用 int main(void) { int a=0,b=0; int cnt=0; while(a<5) { while(b<5) { if(a==2)break; b++; cnt++; } b=0; a++; } printf("cnt=Ò57dcc71-9896-422b-ae91-6c30ec91dcc8n",cnt);//20 return 0; }4.3 goto语句在平常的逻辑代码里面，不推荐使用goto语句。 常用的地方: 错误处理，某某程序初始化失败，就释放资源等操作。#include "stdio.h" //系统里需要有8个状态位，需要存放8个状态位--------当做寄存器使用 int main(void) { int cnt=0; AA: //标签的定义，可以放在函数范围内的任意位置。(不能超出函数范围) printf("123\n"); if(cnt==5)goto DATA; cnt++; goto AA; DATA: return 0; } Goto语句常用在错误处理: #include "stdio.h" //goto语句在错误处理里使用 int main(void) { if(LED_Init()<0) //表示该函数返回值错误 { goto ERROR; } if(KEY_Init()<0) //表示该函数返回值错误 { goto ERROR; } /*....*/ /*....*/ ERROR: //释放资源，结束程序 return 0; }4.4 Switch语句Switch语句主要用在多分支选择结构----有很多种条件/情况。 实际代码里，常用于菜单选择:#include "stdio.h" int main(void) { switch(cmd) //cmd的值传入之后，与case后面的比较，成功之后再执行语句 { case 1: //case 后面值只能是常量，而且不能重复 break; //跳出最近的一层switch语句 case 2: { /*......*/ break; } case 3: break; /*......*/ default: //类似于else printf("所有的条件都不成立!\n"); } return 0; }示例:#include "stdio.h" //投票系统,有3个待选举的人，A,B,C ,有10张票 int main(void) { int i; int A=0,B=0,C=0; int data; for(i=0;i<10;i++) { printf("请投票(范围1~3):"); scanf("%d",&data); switch(data) //data的值传入之后，与case后面的比较，成功之后再执行语句 { case 1: //case 后面值只能是常量，而且不能重复 A++; break; //跳出最近的一层switch语句 case 2: B++; break; case 3: C++; break; // default: //类似于else } } printf("A=Ò57dcc71-9896-422b-ae91-6c30ec91dcc8n",A); printf("B=Ò57dcc71-9896-422b-ae91-6c30ec91dcc8n",B); printf("C=Ò57dcc71-9896-422b-ae91-6c30ec91dcc8n",C); return 0; }

当前文章复盘C语言的数组： 数组定义规则、数组空间类型、数组下标使用、数组存放的数据类型、数组数据替换、插入、输入、输出、字符串输入、输出、长度计算等等。一、数组概念数组是一个相同类型元素的集合。定义数组语法: <数据类型><数组名称>[数组的大小]; int data [100];解释:定义一个int类型数组名称是data，可以存放100int类型的数据,总大小字节: 100*4。<数据类型> 可以填充那些参数？基本数据类型(char 。。float、int。。。。。)、结构体数据类型、指针类型等。数组概念说明（1）[]称为下标符号，用来操作数组。比如: b=a[10]; //将a数组里第10个元素取出来赋值给b变量。（2）.访问数组时，下标的范围是从0开始。比如: int a[10]; 下标范围: 0~9（3）.数组在定义时，[]下标里填充的大小必须是常量。(C89标准) 比如: int a[b]; //错误 int a[10];（4）.数组只有在定义的时候，才可以整体赋值。比如: int a[10]={12,34,56,78,90};（5）.数组在定义的时候，如果赋了值，[]下标里可以不用指定大小。 比如: int a[]={12,34,56};（6）.数组在定义的时候，至少给一个下标赋了初始值，其他下标默认置为0。比如: int a[10]={0};#include int main(void) { int buff_i[10]={10,20,30}; //定义整数类型数组 float buff_f[10]={10.123,20.123,30.123}; //定义浮点数类型数组 char buff_c[10]="123456";//定义字符串类型数组,结尾多了一个结束符"\0" //说明: 在C语言里面没有专用字符串类型，字符串本身还是使用char类型定义。Qstring Sting char buff[10]={'1','2','3','4'}; //定义字符类型数组 int i; //打印整型 for(i=0;i<10;i++) { printf("%d ",buff_i[i]); } printf("\n"); //打印浮点类型 for(i=0;i<10;i++) { printf("%f ",buff_f[i]); } printf("\n"); //打印字符串 printf("%s\n",buff_c); //打印字符类型 for(i=0;i<10;i++) { printf("%c ",buff[i]); } printf("\n"); return 0; }二、数组输入输出#include //从键盘上录入一串数据，倒序输出 int main(void) { int i; int buff[5]; printf("请输入5个数据:"); for(i=0;i<5;i++) { scanf("%d",&buff[i]); //从键盘上录入数据 } for(i=5-1;i>=0;i--) { printf("%d ",buff[i]); //将数据打印到控制台终端 } printf("\n"); return 0; }三、数组的练习题目（1）. 从键盘上录入一串数据(整数)，将数组里的10替换成66，并统计替换的数量。#include int main(void) { //将数组里的10替换成66，并统计替换的数量。 int buff[10]={10,34,10,347,23,10,123,56,78,10}; int i,cnt=0; for(i=0;i<10;i++) { if(buff[i]==10) { cnt++; //记录数量 buff[i]=66; } } printf("替换的数量Þca358bc-a147-43ad-b7f5-de217dd79d2dn",cnt); for(i=0;i<10;i++) { printf("%d ",buff[i]); } printf("\n"); return 0; }（2） 计算数组的大小int main(void) { int buff[]={10,34,10,347,23,10,123,56,78,10,45,10,10}; //34,347,23,123,56,78 int len=10; printf("buff数组的总大小=Þca358bc-a147-43ad-b7f5-de217dd79d2dn",sizeof(buff)); printf("buff数组有%d个成员\n",sizeof(buff)/sizeof(buff[0])); return 0; }（3）从键盘上输入一串数据(整数),将数组里大于10的数据删除掉。//比如: char buff[]={12,34,8,4,7,100}; //最终的结果:{8,4,7,0,0,0} #include /* 从键盘上输入一串数据(整数),将数组里大于10的数据删除掉。 */ int main(void) { int buff[13]={1,34,2,347,23,3,123,56,78,4,45,5,6}; int len=13; int i,j; for(i=0;i10) //当if条件成立的时候,i就是当前需要覆盖数据下标 { //将后面的所有数据向前移动一位 for(j=i;j四、字符串（1）字符串大小计算示例char str1[]={'A','B','c'}; //3 char str2[]="ABC"; //4 printf("str1=Þca358bc-a147-43ad-b7f5-de217dd79d2dn",sizeof(str1)); //3 printf("str2=Þca358bc-a147-43ad-b7f5-de217dd79d2dn",sizeof(str2)); //4 //为什么是4 ？因为字符串结尾自带一个'\0' // '\0'表示是字符串的结束符号（2）字符串的长度计算#include int main(void) { char str[100]; //字符串如何从键盘上录入? scanf("%s",str); //从键盘上录入一个字符串 //str为什么不加&符号? 因为数组的名称就是地址(表示是数组首地址)。 //字符串如何输出? printf("str=%s\n",str); //如何知道从键盘上输入了多少个字符? //首先得知道一点: 字符串结尾符'\0' 字符 int i=0; while(str[i]!='\0') //判断字符串的结束符 { i++; } printf("字符串的长度=Þca358bc-a147-43ad-b7f5-de217dd79d2dn",i); return 0; }（3）字符串的衔接符号#include int main(void) { char str[100]="3847tr45gt\ // \表示字符串的衔接符号 rhonrbngfbn\ gf"; return 0; }

字符串标准处理函数介绍（string.h）、指针和数组当做函数形参，指针定义、函数返回指针、void类型定义指针、类型强制转换、常量声明、extern外边引用声明关键字。1. 总结字符串相关的处理函数string.h里常用的字符串处理相关函数。字符串: string.h void *memcpy(void *restrict, const void *restrict, size_t); int memcmp(const void *, const void *, size_t); void *memset(void *, int, size_t); char *strcat(char *restrict, const char *restrict); int strcmp(const char *, const char *); char *strcpy(char *restrict, const char *restrict); size_t strlen(const char *); char *strncat(char *restrict, const char *restrict, size_t); int strncmp(const char *, const char *, size_t); char *strncpy(char *restrict, const char *restrict, size_t); char *strstr(const char *, const char *); 格式化打印(转换)函数: int sprintf(char *str, const char *format, ...); int snprintf(char *str, size_t size, const char *format, ...); int sscanf(const char *str, const char *format, ...);说明: char p; // a=aa; //乘法 char *p; //定义指针 指针用于代表一个地址。 指针可以当做数组使用，数组无法当做指针使用。数组的名称: 就是首地址 在C语言里任何类型的指针(地址)是4个字节2. 函数参数: 指针与数组类型函数的形参: 指针类型与数组类型 示例代码： ()#include //标准输入输出 #include //字符串处理头文件 int my_strlen1(char buff[]); int my_strlen2(char *buff); int main(int argc,char **argv) { char str[]="1234567890"; int len1=my_strlen1(str); int len2=my_strlen2(str); printf("Ý53f2443-8257-4cfc-9ad3-d73c15530735n",len1); printf("Ý53f2443-8257-4cfc-9ad3-d73c15530735n",len2); return 0; } /* 函数功能:计算字符串的长度 char buff[] :传入是数组类型，也就是传入的是地址 */ int my_strlen1(char buff[]) { int cnt=0; while(buff[cnt]!='\0') { cnt++; } return cnt; } /* 函数功能:计算字符串的长度 char *str :传入是字符指针类型，也就是传入的是地址 */ int my_strlen2(char *buff) { int cnt=0; while(buff[cnt]!='\0') { cnt++; } return cnt; }3. 数组当做函数形参的问题示例: #include //标准输入输出 #include //字符串处理头文件 void my_func1(char buff[100]); void my_func2(char *buff); void sum(int a); int main(int argc,char **argv) { int a=100; char str[100]="12345"; my_func1(str); my_func2(str); sum(a); return 0; } //char buff[100] 函数形参里是地址不会申请空间 void my_func1(char buff[100]) { char buff1[100]; printf("sizeof=Ý53f2443-8257-4cfc-9ad3-d73c15530735n",sizeof(buff)); printf("sizeof1=Ý53f2443-8257-4cfc-9ad3-d73c15530735n",sizeof(buff1)); } void my_func2(char *buff) { printf("sizeof=Ý53f2443-8257-4cfc-9ad3-d73c15530735n",sizeof(buff)); }4. 指针定义: 存放地址#include //标准输入输出 #include //字符串处理头文件 int main(int argc,char **argv) { int a=100; char str[100]="123456"; char *p; //定义的是一个指针(地址) p=str; //可以赋值 //p=&a; //可以赋值 printf("%p\n",&a); printf("%p\n",str); printf("%p\n",p); printf("%s\n",str); printf("%s\n",p); return 0; }5. 函数形参和返回值: 都是地址（1）数组类型可以当做函数形参。void func(char buff[]){}（2）数组类型不能当做函数返回值类型。char buff[] func(void){} 错误的 函数如果要返回地址类型: 必须使用指针类型。 函数形参如果要传入地址类型: 可以使用指针类型或者数组类型。示例代码:#include //标准输入输出 #include //字符串处理头文件 char *func(char buff[]); int main(int argc,char **argv) { char str[]="12345"; char *str1=func(str); printf("%p\n",str); printf("%p\n",str1); printf("%s\n",str1); return 0; } //形参是一个数组类型(char的地址) //返回值是一个char类型的地址 char *func(char buff[]) { return buff; } 示例代码(局部地址是不能返回的) #include //标准输入输出 #include //字符串处理头文件 char *func(void); int func1(void); int main(int argc,char **argv) { char *str=func(); printf("str=%s\n",str); printf("str2=%p\n",str); int a=func1(); printf("a=Ý53f2443-8257-4cfc-9ad3-d73c15530735n",a); return 0; } char *func(void) { char str[]="5thgtrgbtfbfgbgf"; //static char str[]="5thgtrgbtfbfgbgf"; //加了静态关键字之后,数据空间永久保留(与main函数生命周期一样) printf("str1=%p\n",str); return str; //将数据空间的地址返回,将地址赋值给接收返回值的指针变量 } int func1(void) { int a=88; return a; //a变量里的数据取出来返回去，赋值给接收返回值的变量。 }6. void*类型指针#include //标准输入输出 #include //字符串处理头文件 void func(void *p); int main(int argc,char **argv) { int buff[100]; char str[100]; func(buff); func(str); return 0; } /* void *p:传入的形参自适应 */ void func(void *p) { } //void a; //语法是错误的 //int a; //定义一个int类型变量,空间是4个字节 //void *p //指针本身是存放地址，任何类型的指针都是4个字节7. 强制转换强制转换只是欺骗编译器，消除警告，不会改变本身的数据类型。 示例代码: 指针之间的强制转换#include //标准输入输出 #include //字符串处理头文件 void func(int *p); int main(int argc,char **argv) { char str[]="123456789"; func((int*)str); //强制转换语法 return 0; } /* void *p:传入的形参自适应 */ void func(int *p) { char *str=(char*)p; printf("str=%s\n",str); }8. 常量声明关键字: const#include //标准输入输出 #include //字符串处理头文件 int main(int argc,char **argv) { char buff[100]="123"; const char *p=buff; //表示p指向的buff的空间数据是不能修改的 //*p='A'; //不能修改 赋值是错误的 p[0]='A'; //不能修改 赋值是错误的 //const int a=99;//定义a是只读变量。 //a=88; //赋值是错误的 return 0; }9. extern外部声明关键字主要是用在头文件里，多文件编程中。 #include //标准输入输出 #include //字符串处理头文件 extern void func(void);//外部引用声明 extern int data; //外部引用声明 int main(int argc,char **argv) { func(); printf("Ý53f2443-8257-4cfc-9ad3-d73c15530735n",data); return 0; } int data=888; //定义变量 void func(void) { printf("123\n"); }

复盘C语言数组的练习题：涉及到数组插入、数组删除、数组下标数据的左移右移、数组排序、数组排序优化、数组的数据拼接等等。（1）函数基本使用: 函数基本定义、封装、传参、调用、局部变量、全局变量、只读变量、静态变量 （2）数组基本使用: 数组基本定义、使用赋值、字符串。1. 数组基本知识1. 概念: 同一个类型的集合。 2. 定义: int data[100]; //数组data里可以存放100个int类型 100必须是常量（C89）。定义数组时，如果没有赋初始值[]一定要填大小。 int data[]={1}; 3.数组赋值: 只有在定义的使用才可以整体赋值。int data[10]={12,34,56,7,89}; 4.数组下标[]访问从0开始。 比如: buff[100]; 下标范围: 0~99 5.数组的名称就是首地址。int buff[100]; 1.2 字符串数组 1. 字符串录入: scanf(“%s”); gets() fgets 2. 头文件: string.h 3. 从键盘录入字符串的方法 scanf("%s",str); //从键盘上录入字符串,字符串结尾: '\0' gets(str); //从键盘上录入字符串 fgets(str,100,stdin); //从键盘上录入字符串 (标准输入) #include int main(int argc,char **argv) { int int_data[100]={12,34,56,78}; //整型数组 char char_data[]={'A','B','C'}; //字符数组 char str1_data[]={'A','B','C','\0'}; //字符串数组 char str2_data[]="ABC";//字符串数组 printf("char_data=ß3fa3b55-b4a1-4e93-bad7-bbde26658045n",sizeof(char_data)); //3 printf("str1_data=ß3fa3b55-b4a1-4e93-bad7-bbde26658045n",sizeof(str1_data)); //4 printf("str2_data=ß3fa3b55-b4a1-4e93-bad7-bbde26658045n",sizeof(str2_data)); //4 return 0; } 字符串数组特性: 结尾有’\0’2. 数组相关的题目(分析)2.1 数组的数据插入int a[]={1,2,3,4,5,6,7}; 在第2位数据后插入一个888 结果: 1,2,888,3,4,5,6,7 #include int main(int argc,char **argv) { int data[10]={1,2,3,4,5,6,7,8,9}; //1,2,3,4,4,5,6,7,8,9 int addr; int i; printf("输入插入的位置:"); scanf("%d",&addr); /*1. 向后移动数据，空出位置*/ for(i=8;i>=addr;i--) { data[i+1]=data[i]; } /*2. 查看移动之后的效果*/ for(i=0;i<10;i++)printf("%d ",data[i]); printf("\n"); data[addr]=888; //插入的数据 /*3. 最终效果*/ for(i=0;i<10;i++)printf("%d ",data[i]); printf("\n"); return 0; }2.2 数组数据的删除int a[]={1,2,3,4,2,6,7}; 将第2位数据删除掉 结果: 1,3,4,5,6,7 示例: #include int main(int argc,char **argv) { int data[10]={1,2,3,4,5,6,7,8,9,10}; //1,2,4,5,6,7,8,9,10,10 int addr; int i; printf("输入删除的位置:"); scanf("%d",&addr); //2 /*1. 向前移动,将数据覆盖掉*/ for(i=addr-1;i<10-1;i++) { data[i]=data[i+1]; } /*2. 查看移动之后的效果*/ for(i=0;i<9;i++)printf("%d ",data[i]); printf("\n"); return 0; }2.3 变量排序数组数据排序。从键盘上输入一串数据(整数)，从大到小排序，再输出。int a[]={12,67,45,13,1,5}; 排序之后: 67,45,13,12,5,1排序: 计算平均数。班级成绩、温度数据......例子: 从键盘上随机输入3个数，将3个数按照从大到小的顺序输出。#include int main(int argc,char **argv) { int a,b,c; int tmp; //存放临时数据 printf("请输入3个数:"); scanf("%d%d%d",&a,&b,&c); //以回车作为结束符号,以空格作为间隔符号 printf("源数据:%d,%d,ß3fa3b55-b4a1-4e93-bad7-bbde26658045n",a,b,c); //从大到小 if(a2.4 数组冒泡排序#include int main(int argc,char **argv) { int data[10]; int tmp; //存放临时数据 int i,j; int cnt=0; //排序比较的总次数 /*1. 录入数据*/ printf("请输入10个数:"); for(i=0;i<10;i++)scanf("%d",&data[i]); /*2. 打印源数据:*/ printf("源数据:"); for(i=0;i<10;i++)printf("%d ",data[i]); printf("\n"); /*3. 冒泡排序*/ for(i=0;i<10-1;i++) //比较轮数 { for(j=0;j<10-1-i;j++) //每一轮比较的次数 { if(data[j]>data[j+1]) //从小到大 { tmp=data[j]; data[j]=data[j+1]; data[j+1]=tmp; } cnt++; } } /*4. 打印结果数据:*/ printf("排序之后的数据:"); for(i=0;i<10;i++)printf("%d ",data[i]); printf("\n"); printf("排序的总次数:ß3fa3b55-b4a1-4e93-bad7-bbde26658045n",cnt); return 0; }分析:/* data[]={1,2,3} 第一轮: [0]和[1] [1]和[2] 2 3 1 每一轮保证最小的数在最后 第二轮: [0]和[1] 3 2 1 */ 排序: 从大到小 1 2 3 4 5 第一轮: (1) 2 1 3 4 5 (2) 2 3 1 4 5 (3) 2 3 4 1 5 (4) 2 3 4 5 1 第二轮: (1) 3 2 4 5 1 (2) 3 4 2 5 1 (3) 3 4 5 2 1 (4) 3 4 5 2 1 第三轮: (1) 4 3 5 2 1 (2) 4 5 3 2 1 (3) 4 5 3 2 1 (4) 4 5 3 2 1 第四轮: (1) 5 4 3 2 1 (2) 5 4 3 2 1 (3) 5 4 3 2 1 (4) 5 4 3 2 12.5 冒泡排序优化#include int main(int argc,char **argv) { int data[10]; int tmp; //存放临时数据 int i,j; int cnt=0; //排序比较的总次数 45: int flag=0; //标志位置 /*1. 录入数据*/ printf("请输入10个数:"); for(i=0;i<10;i++)scanf("%d",&data[i]); /*2. 打印源数据:*/ printf("源数据:"); for(i=0;i<10;i++)printf("%d ",data[i]); printf("\n"); /*3. 冒泡排序*/ for(i=0;i<10-1;i++) //比较轮数 { for(j=0;j<10-1-i;j++) //每一轮比较的次数 { if(data[j]>data[j+1]) //从小到大 { tmp=data[j]; data[j]=data[j+1]; data[j+1]=tmp; flag=1; } cnt++; } if(flag==0) //不需要继续排序 { break; //跳出最外层循环 } flag=0; //清除标志位，方便第2次判断 } /*4. 打印结果数据:*/ printf("排序之后的数据:"); for(i=0;i<10;i++)printf("%d ",data[i]); printf("\n"); printf("排序的总次数:ß3fa3b55-b4a1-4e93-bad7-bbde26658045n",cnt); return 0; }分析:data[]={1,2,3} 第一轮: [0]和[1] [1]和[2] 2 3 1 每一轮保证最小的数在最后 第二轮: [0]和[1] 3 2 12.6 数组数据的拼接(整数)int a[]={1,3,4,5,6,7}; int b[]={11,13,14,15,16,17};将a和b拼接到c数组里。 最终int c[]={1,3,4,5,6,7, 11,13,14,15,16,17} 必须保证c数组空间足够大。示例代码:#include int main(int argc,char **argv) { int src_data[10]={1,2,3,4,5}; int new_data[]={6,7,8,9}; // int i; for(i=0;i