一、数据类型
常量
1、通过预处理声明常量
#include <stdio.h>
#define PRICE 100
int main() {
printf("价格：%d\n",PRICE);
return 0;
}
2、通过 const 关键字声明常量
#include <stdio.h>
const int NUM=10;
int main() {
printf("数量：%d\n",NUM);
return 0;
}
区别：#define 在运行时会替换为指定的值，const可以看到数据类型，更推荐使用 const
整型
在C语言中分为有符号和无符号整型，无符号是整数，有符号包含负数
| short | 2字节 |
| int | 4字节 |
| long | 32位系统4字节，64位系统8字节 |
| long long | 8字节 |
int main() {
int a=10;
int b=-10;
long long c=20;
int d=0b111;//二进制
int e=0xb;//十六进制
int f=010;//八进制
unsigned int g=12;//无符号正数
printf("a=%d,b=%d,c=%d,d=%d",a,b,c,d);
return 0;
}
- 0b 为二进制方式赋值
- 0x 为十六进制数据
- 0 为八进制数据
c11 标准 stdint.h 对数据的长度进行了统一
| int8_t | 统一8位1字节 |
| int16_t | 2字节 |
| int32_t | 4字节 |
| int64_t | 8字节 |
| uint8_t | 无字符1字节 |
浮点数
| float | 单精度，4字节，32位 |
| double | 双精度，8字节，64位 |
| long double | 长双精度，16字节，128位 |
typedef 自定义类型
typedef uint8_t mychar;
int main() {
mychar ch='a';
printf("%c",ch);
return 0;
}
二、goto 跳转
使用 goto 实现循环
int i=0;
aa:
printf("%d\n",i);
i=i+1;
if(i<100){
goto aa;
}
三、输入与输出
相关函数文档参考：C语言stdio.h文档
1、字符输出
putchar：写字符到标准输出，相当于调用 putc
遍历字符并打印
#include <stdio.h>
int main() {
char c;
for (c='a';c<='z';c++) {
putchar(c);
putchar('\n');
}
return 0;
}
查看字符对应整数
#include <stdio.h>
int main() {
char c;
printf("=====小写====\n");
for (c='a';c<='z';c++) {
printf("%d\n",c);
}
printf("=====大写====\n");
for (c='A';c<='Z';c++) {
printf("%d\n",c);
}
return 0;
}
2、字符串输出
puts：写字符串到标准输出
输出字符串示例
#include <stdio.h>
int main() {
char string [] = "Hello world!";
puts(string);
return 0;
}
3、格式化输出
printf：打印格式化数据到标准输出，如果包含格式说明符(以%开头的子串)将格式化，用附加参数替换说明符(说明符可以认为是占位符)。
格式化时用到的说明符
| d 或者 i | 有符号十进制整数 | 392 |
| u | 无符号十进制整数 | 7235 |
| o | 无符号八进制 | 610 |
| x | 无符号十六进制整数 | 7fa |
| X | 无符号十六进制整数（大写） | 7FA |
| f | 十进制浮点，小写 | 392.65 |
| F | 十进制浮点，大写 | 392.65 |
| e | 科学记数法（尾数/指数），小写 | 3.9265e+2 |
| c | 字符 | a |
| s | 字符串 | hello |
| p | 指针地址(内存地址) | b8000000 |
| % | %%打印出一个% | % |
格式化输出示例
#include <stdio.h>
int main() {
printf("字符：%c %c\n",'a',65);
printf("整数：%d %ld\n",600,6500000L);//%ld 长整
printf("浮点数：%f\n",33.3);
printf("十六进制：%x\n",0xffa);
printf("特殊打印：%%\n");
return 0;
}
结果
字符：a A
整数：600 6500000
浮点数：33.300000
十六进制：ffa
特殊打印：%
4、输入字符和字符串
getchar：从标准输入中获取字符
获取字符示例
#include <stdio.h>
int main() {
uint8_t c;
puts("输入文本，在一个句子中包含.以结束:");
do{
c=getchar();
putchar(c);
}while (c!='.');
return 0;
}
gets：从标准输入中获取字符串
获取字符串示例
#include <stdio.h>
int main() {
char str[256];
puts("输入你的名字：");
gets(str);
printf("你的名字：%s\n",str);
return 0;
}
5、格式化输入
scanf：从标准输入中读取格式化数据，格式化说明符可参照 printf
格式化输入示例
#include <stdio.h>
int main() {
char ch;
int num;
char str[10];
puts("输入一个字符：");
scanf("%c",&ch);
printf("用户的输入字符为：%c\n",ch);
puts("输入一个整数：");
scanf("%d",&num);
printf("用户输入的整数为：%d\n",num);
puts("输入字符串：");
scanf("%s",str);
puts(str);
return 0;
}
四、数组
1、一维数组
创建数组方式1：
const int NUMS_LEN=10;
int nums[NUMS_LEN];
演示数组中元素默认值:
#include <stdio.h>
int main() {
const int NUMS_LEN=10;
int nums[NUMS_LEN];
for (int i = 0; i < NUMS_LEN; ++i) {
printf("索引：%d,值：%d\n",i,nums[i]);
}
return 0;
}
创建数组方式2：
int ages[]={19,20,30};
2、二维数组
创建方式1：
int nums[3][4];
for (int i = 0; i < 3; ++i) {
for (int j = 0; j < 4; ++j) {
printf("%d,%d,value=%d\n",i,j,nums[i][j]);
}
}
创建方式2：
int nums[2][3]={
{1,2,3},
{4,5,6}
};
3、字符数组(字符串)
声明字符串并检查长度：
char str[10];
printf("长度：%ld\n",strlen(str));
存入字符串并检查长度：
char str[10]="hello";
printf("长度：%ld\n",strlen(str));
\0作为字符串结尾：
char str[10]="he\0llo";
printf("长度：%ld\n",strlen(str));
char数组填充函数 memset：
memset(要填充的数组,要填充的值,要填充多长)
#include <stdio.h>
#include <string.h>
int main() {
char str[]="你好";
memset(str,1,6);
for (int i = 0; i < 6; ++i) {
printf("%d\n",str[i]);
}
return 0;
}
关于中文：
char str[2]="你好";
printf("长度：%ld\n",strlen(str));//一个汉字占用3字节
五、字符串操作
1、字符串连接
strcat：连接字符串，将源字符串的副本附加到目标字符串。
#include <stdio.h>
#include <string.h>
int main() {
char * str="hello";//要拼接的字符
char result[100];//目标字符
memset(result,0,100);//填充0到目标字符
strcat(result,str);//拼接str到result
strcat(result,"world");//拼接 world 到result
puts(result);
return 0;
}
strncat：连接指定数量的字符到目标字符串
#include <stdio.h>
#include <string.h>
int main() {
char dist[10];
strncat(dist,"hello",3);
puts(dist);
return 0;
}
结果
hel
2、格式化字符串
sprintf：将格式化数据写入字符串(格式方式和其他格式化方法很像)
#include <stdio.h>
#include <string.h>
int main() {
char str[10];
memset(str,0,10);
int len,a=10,b=5;
len=sprintf(str,"%d+%d=%d",a,b,a+b);
printf("格式结果：[%s],长度为：%d",str,len);
return 0;
}
结果：
格式结果：[10+5=15],长度为：7
3、字符串与基础数据类型转换
sscanf：从字符串中读取格式化数据
使用 sscanf 截取数据
#include <stdio.h>
#include <string.h>
int main() {
//原字符串
char sentence[]="Java is 23 years old";
//保存拆分出来的数据的变量
int age;
char name[10];
sscanf(sentence,"%s %*s %d",name,&age);
printf("age is %d,name is %s",age,name);
return 0;
}
使用 sscanf 转换数据类型
#include <stdio.h>
int main() {
char * str="100";
int a;
sscanf(str,"%d",&a);
printf("转换后：%d",a);
return 0;
}
使用 atof 将字符串转为 double
#include <stdio.h>
#include <stdlib.h>
int main() {
double result=atof("3.14");
printf("转换后：%f",result);
return 0;
}
4、字符串比较
== 用来比较两个变量的内存地址，不能比较字符串的值。使用 strcmp 比较两个字符串的值，两个字符串的值相等返回 0。
#include <stdio.h>
#include <string.h>
int main() {
char * str1="hello";
char str2[]="hello";
if(strcmp(str1,str2)==0){
puts("两个字符串的值相等");
}else{
puts("两个字符串的值不相等");
}
return 0;
}
5、字符串的截取
strchr：从指定字符开始截取
#include <stdio.h>
#include <string.h>
int main() {
char * str="helloworld";
char * result=strchr(str,'w');
puts(result);
return 0;
}
strrchr：从最后一个指定字符开始截取
#include <stdio.h>
#include <string.h>
int main() {
char * str="helloworld";
char * result=strrchr(str,'l');
puts(result);
return 0;
}
strstr：从指定字符串开始截取
#include <stdio.h>
#include <string.h>
int main() {
char * str="helloworld";
char * result=strstr(str,"wo");
puts(result);
return 0;
}
strncpy：从字符串中复制指定长度字符
#include <stdio.h>
#include <string.h>
int main() {
char * str="helloworld";
char dest[10];
strncpy(dest,str,5);
puts(dest);
return 0;
}
使用指针从指定位置开始截取
#include <stdio.h>
#include <string.h>
int main() {
char * str="helloworld";
char * str1=str+5;
puts(str1);
return 0;
}
六、函数
声明和调用的方式和java很相似
1、main 函数的参数
main 函数的参数，也是程序运行时的参数
声明时需指定：1.参数的长度，2.参数数组
#include <stdio.h>
int main(int argc,char ** argv) {
printf("参数的个数：%d\n",argc);
for (int i = 0; i < argc; ++i) {
printf("参数 %d 的值：%s\n",i,argv[i]);
}
return 0;
}
2、可变参数
#include <stdio.h>
#include <stdarg.h>
void testarg(int n,...){
printf("参数的个数:%d\n",n);
va_list args;
va_start(args,n);
for (int i = 0; i < n; ++i) {
int temp=va_arg(args,int);
printf("参数：%d\n",temp);
}
va_end(args);
}
int main(int argc,char ** argv) {
testarg(2,10,55);
return 0;
}
七、预处理
1、预设常量
除了可以用 #define 定义一个常量，还可以在编译参数中指定预设常量的值
编写没有声明常量但使用了常量的代码
#include <stdio.h>
int main() {
printf("The num is %d\n",THE_NUM);
return 0;
}
使用命令进行编译和运行
gcc -o test main.c -DTHE_NUM=4
test.exe
2、编译条件针对不同平台编译
1.编写代码
#include <stdio.h>
#define WIN 1
#define LINUX 2
#define MAC 3
int main() {
#if PLATFORM==WIN
printf("Hello Windows\n");
#elif PLATFORM==LINUX
printf("Hello Linux\n");
#elif PLATFORM==MAC
printf("Hello MAC\n");
#else
printf("Unknow platform\n");
#endif
return 0;
}
2.编译时指定条件
//编译源码
gcc -o test main.c -DPLATFORM=1
//运行
test.exe
3、头文件重复引入
1、演示重复引入
1.创建a.h
#include "b.h"
2.创建b.h
#include "a.h"
3.引入a.h
#include <stdio.h>
#include "a.h"
int main() {
return 0;
}
2、防止头文件重复引入
修改a.h
#ifndef A_H
#define A_H
#include "b.h"
#endif
修改b.h
#ifndef B_H
#define B_H
#include "a.h"
#endif
八、指针
声明一个变量后，系统会为这个变量分配内存空间，每个变量都有一个内存地址，相当于旅馆的房间号。
我们要获取变量中的值需要通过内存地址来找到对应的值，但是还有另一种情况是这个变量中存放的是另个一变量的内存地址。这就好像你通过房间号找到这个房间，发现在这个房间里面是另一个房间的房间号。
所以，一个变量的地址就成为该变量的指针。
声明指针并指向一个变量的地址
#include <stdio.h>
int main() {
int *a,*b;
int i=10;
a=&i;
b=&i;
printf("a的值为：%d\n",*a);
printf("b的值为：%d\n",*b);
i=99;
printf("a的值为：%d\n",*a);
printf("b的值为：%d\n",*b);
return 0;
}
指针的大小
#include <stdio.h>
int main() {
int *a;
printf("size is %ld\n", sizeof(a));
return 0;
}
1、函数指针
有参无返回值的函数指针
#include <stdio.h>
void hello(int a,char* c){
printf("hello\n");
}
int main() {
void(*fp)(int,char*)=&hello;
fp(1,"");
return 0;
}
有参有返回值的函数指针
#include <stdio.h>
int test(int a){
printf("hello:%d\n",a);
return a;
}
int main() {
int(*fp1)(int)=&test;
int result=fp1(11);
printf("返回值:%d\n",result);
return 0;
}
给函数指针设定类型别名
#include <stdio.h>
void hello(){
printf("Hello\n");
}
typedef void(*SimpleHello)();
int main() {
SimpleHello h1=&hello;
h1();
SimpleHello h2=&hello;
h2();
return 0;
}
2、无类型指针
无类型指针可以代表所有类型的数据
无类型指针存放字符串
#include <stdio.h>
int main() {
void *test="Hello";
printf("%s\n",test);
return 0;
}
九、结构体与共同体
1、结构体
主要用结构体描述属性
定义使用结构体
#include <stdio.h>
struct File{
char* name;
int size;
};
int main() {
struct File file;
file.name="a.txt";
file.size=10;
printf("文件 %s 的大小为 %d\n",file.name,file.size);
struct File file1={"a.jpg",100};
printf("文件 %s 的大小为 %d\n",file1.name,file1.size);
return 0;
}
定义结构体类型简化代码
#include <stdio.h>
typedef struct _File{
char* name;
int size;
}File;
int main() {
File file;
file.name="a.txt";
file.size=10;
printf("文件 %s 的大小为 %d\n",file.name,file.size);
File file1={"a.jpg",100};
printf("文件 %s 的大小为 %d\n",file1.name,file1.size);
return 0;
}
2、结构体的内存对齐
结构体所占大小如何计算的？结构的大小由各变量与字节最大变量对齐后相加得出。
如图所示，三种情况：
1.当定义第一个变量大小为1字节，第二个变量比第一个变量大时，第一个变量要对齐大的变量，第一个变量填充为2字节，结构体大小为4字节。
2.前两变量加起来不足对齐第三个变量的大小，所以填充2字节对齐，结构体大小为8字节。
3.前4个变量加起来刚好对齐第5个变量的大小，无须对齐。最后一个变量没有对齐则填充2个字节对齐第5个变量，所以结构体大小为12字节。
#include <stdio.h>
typedef struct _Data{
uint8_t a;//1
uint8_t b;//1
uint8_t c;//1
uint8_t d;//1
uint32_t e;//4
uint8_t f;//1
}Data;
int main() {
printf("size is %d\n", sizeof(Data));
return 0;
}
3、结构体指针
没有使用指针前
#include <stdio.h>
typedef struct _Dog{
char * color;
int age;
}Dog;
int main() {
Dog dog1={"红色",2};
Dog dog2=dog1;
dog1.age=3;
printf("(dog1 color is %s,age is %d),(dog2 color is %s,age is %d)\n"
,dog1.color,dog1.age,dog2.color,dog2.age
);
return 0;
}
使用结构体指针
#include <stdio.h>
typedef struct _Dog {
char *color;
int age;
} Dog;
int main() {
Dog dog1 = {"红色", 2};
Dog *dog2 = &dog1;
dog1.age = 3;
printf("(dog1 color is %s,age is %d),(dog2 color is %s,age is %d)\n",
dog1.color, dog1.age, dog2->color, dog2->age);
return 0;
}
通过函数创建和销毁结构体指针
#include <stdio.h>
#include <stdlib.h>
typedef struct _Dog {
char *color;
int age;
} Dog;
Dog* createDog(char* color,int age){
Dog* dog=malloc(sizeof(Dog));
dog->color=color;
dog->age=age;
return dog;
}
void deleteDog(Dog* dog){
free(dog);
}
int main() {
Dog* dog1=createDog("红色",3);
printf("(dog1 color is %s,age is %d)\n",
dog1->color, dog1->age);
deleteDog(dog1);
return 0;
}
3、共同体
共同体的特点：共同体中声明的所有变量共用一块空间
声明及使用共同体
#include <stdio.h>
typedef union _BaseData{
char ch;
uint8_t ch_num;
}BaseData;
int main() {
BaseData data;
data.ch='A';
printf("ch_num is %d size is %d\n",data.ch_num, sizeof(BaseData));
return 0;
}
实现颜色的操作
#include <stdio.h>
//定义颜色结构体
typedef struct _ColorARGB{
uint8_t blue;
uint8_t green;
uint8_t red;
uint8_t alpha;
}ColorARGB;
//定义颜色共同体
typedef union _Color{
uint32_t color;
ColorARGB colorARGB;
}Color;
int main() {
Color c;
c.color=0xFFAADD00;
printf("red:%X",c.colorARGB.red);
return 0;
}
十、文件操作
fopen函数：以指定文件名和模式获取一个流的FILE指针。
支持的模式
| "r" | 读：文件必须存在 |
| "w" | 写：创建一个文件，如果已经存在则覆盖 |
| "a" | 追加：向文件末尾追加内容，如果文件不存在则创建该文件 |
| "r+" | 可做读取和修改的操作，文件必须存在 |
写文件
//创建文件指针
FILE * file=fopen("a.txt","w");
if (file){
//写入内容
fputs("HelloWorld",file);
//关闭
fclose(file);
}else{
puts("文件操作失败！");
}
读文件
#include <stdio.h>
int main() {
FILE * file=fopen("a.txt","r");
if (file){
char ch;
while(1){
ch=fgetc(file);
if(ch!=EOF){
printf("%c\n",ch);
}else{
break;
}
}
fclose(file);
}
return 0;
}