程序基本结构
#include <stdio.h> 指定头文件，想使用函数库中的函数必须指明
int main() // 程序入口
{
int a = 111, b = 222, sum;
sum = a + b;
printf("和是 %d
", sum); // 输出语句，%d是十进制占位符
return 0;
}
常量变量标识符
常量
整型常量 1000
实型常量 12.34 12.34e2
字符常量
字符 's'
转义字符
101（8进制）x42（16进制）
字符串常量 "aa"
符号常量 #define PI 3.1415926
程序编译后替换所有PI
变量
先声明后使用 int a = 11;
常变量，不允许修改值 const int a = 111;
标识符
只能由数字，字母，下划线组成，开头必须是字母或者下划线
数据类型
整型类型
基本整型 int
Turbo C2.0中占用2个字节，Visual C++中占用4个字节
短整型 short int
Turbo C2.0中占用2个字节，Visual C++中占用2个字节
长整型 long int
long a = 111L;
Turbo C2.0中占用4个字节，Visual C++中占用4个字节
双长整型 long long int
Turbo C2.0中占用8个字节，Visual C++中占用8个字节
说明：以上几种数据类型，可以添加unsigned表示正值，如 unsigned int. 默认值signed，无符号类型的存储范围可以扩大一倍
注意，小数（实型）不能使用unsigned修饰 unsigned int a = 3;printf("%u
", a);
字符型 char，占用一个字节，也可以添加unsigned修饰
char a = 'a';
printf("%c
", a);
布尔型 bool，1代表真，0代表假
bool的使用需要引入标准库，#include <stdbool.h>
bool x = true;
如果不想引入标准库，可以直接使用_Bool x = 1;
使用sizeof可以得出类型的占用字节数 sizeof (int)
浮点类型（实型）
单精度浮点型 float，占用4个字节
双精度浮点型 double，占用8个字节
double a = 1;
printf("%.2lf
", a); // 保留2位小数
长双精度浮点型 long double
Turbo C2.0中占用16个字节，Visual C++中占用8个字节
基本类型转换
基本数据类型可以进行强制类型转换，如
double a = 1;
float b = (float)a;
字符串
字符串不可修改，结束标志是 ' '
char* str = "hello, world";
char const* s1 = "foobar"; 定义字符串的最佳实践
char* s = "Hello" ", " "World"; 字符串自动聚合
函数类型
int main()
{
int max(int x, int y); // 使用自定义函数之前，必须再定义一次
int a, b, c;
scanf_s("%d和%d", &a, &b); // 收集用户输入的数据，&是地址符，表示将输入的数据传递给变量
c = max(a, b);
printf("max=%d
", c);
return 0;
}
int max(int x, int y) { // 定义函数
int z;
if (x > y) {
z = x;
}
else {
z = y;
}
return z;
}
空参数的函数定义
int min(void) { return 0; }
int min() {return 0;}
枚举类型 enum
enum test {
first = 1, second, third
};
enum test a = second;
printf("%d
", a); // 2
数组类型
一维数组
int arr[10]; 声明
arr[0] = 10; 赋值
int arr[2] = { 10,11 }; 初始化
int arr[] = { 10,11 };
二维数组
int arr[2][3]; 声明
arr[0][0] = 1; 赋值
int arr[2][3] = { {1, 2, 3}, {4, 5, 6} }; 初始化
int arr[2][3] = { 1, 2, 3, 4, 5, 6 };
int arr[][3] = { 1, 2, 3, 4, 5, 6 };
字符数组
字符串的存储形式就是字符数组
char arr[] = "so easy"; 声明
char arr[] = { "so easy" }; 系统自动在数组末尾添加 ' '
printf("%s
", arr);
输入输出不需要地址符&
char arr[5];
scanf("%s", arr);
printf("%s
", arr);
结构体类型
结构体的作用是声明自定义数据类型
基本使用
struct Student
{
char name[10];
int age;
char sex[4];
} student1, student2; // 定义类型并声明变量
struct Class
{
char ClassName[10];
struct Student s; // 可以实现嵌套struct
};
struct Class class1 = { "初一10班", {"叶家伟", 10, "女"} }; // 声明变量，struct Class表示类型
printf("%s|%s|%d|%s
", class1.ClassName, class1.s.name, class1.s.age, class1.s.sex);
结构体数组
struct stu
{
int a;
};
struct stu arr[3] = { {1},{2},{3} };
for (int i = 0; i < 3; i++) {
printf("%d
", arr[i].a);
}
共用体类型
共用体类型和结构体类似，不过共用体中的成员共用内存空间，以最长的数据类型所占的空间为主
union test
{
int i;
float j;
char c;
};
union test a;
a.i = 99;
printf("%d
", a.i); // 99
printf("%f
", a.j); // 0.000000
printf("%c
", a.c); // c
共用体类型只能对一个成员赋值
字符串函数
puts
输出字符数组
char arr[] = "so ea sy";
puts(arr);
gets
输入字符数组
char arr[5];
gets(arr); // 注意输入aaaa，系统默认末尾添加 表示5个字符
strcat
需要 #include <string.h>
字符数组拼接，将结果放到第一个参数中
char arr[12] = "nihao";
char arr1[6] = "buhao";
strcat(arr, arr1);
puts(arr); // "nihaobuhao"
strncat
需要 #include <string.h>
指定拼接字符个数
strncat(arr, arr1, 2); // "nihaobu"
strcpy
需要 #include <string.h>
给字符数组赋值
char arr[5];
strcpy(arr, "aa");
char arr[5], arr1[5] = "bb";
strcpy(arr, arr1);
strncpy
需要 #include <string.h>
给字符数组赋值指定个数字符
char arr[5], arr1[5] = "abcd";
strncpy(arr, arr1, 2);
arr[2]=' ';
puts(arr); // "ab"
sprintf
格式化字符串
char str [50];
sprintf (str, "格式化后的字符串: %s = %i", "1+1",2);
printf ("%s
", str); // 格式化后的字符串: 1+1 = 2
snprintf
指定字符长度
使用snprintf(b, sizeof(b), "%s", a);
strcmp
用来比较两个字符串的大小
char arr[5] = "111", arr1[5] = "222";
int result = strcmp(arr, arr1);
英文字母小写比大写大，排在后面的比前面大
arr大于arr1的，函数返回正整数，小的返回负整数，相等返回0
A的ascll码是65
a的ascll码是97
strncmp
指定比较字符的个数
printf("%i
", strncmp("ABC","AB", 3));
strcasecmp
比较，不区分大小写
printf("%i
", strcasecmp("AB","aB"));
strncasecmp
指定字符个数比较
printf("%i
", strncasecmp("ABC","aB", 2));
strlen
需要 #include <string.h>
返回字符串实际长度
char arr[5] = "111";
int result = strlen(arr);
strlwr
转小写
char arr[5] = "AAA";
strlwr(arr);
printf("%s
", arr);
strupr
转大写
atoi
需要 #include <stdlib.h>
字符串转数值
printf("%i
", atoi("a1a")); // 0
printf("%i
", atoi("1a")); // 1
strchr
需要 #include <string.h>
查找第一个匹配的元素，并且截取所有后面的字符
char *result = strchr("abcba", 'b');
printf("%s
", result); // bcba
strrchr
需要 #include <string.h>
查找第一个匹配的元素，并且截取所有前面的字符
char *result = strrchr("abcba", 'b');
printf("%s
", result); // ba
strspn
查找匹配段长度
printf("%i
", strspn("abcdef", "abd")); //2
strcspn
需要 #include <string.h>
查找第一个匹配字符的索引位置
printf("%i
", strcspn("abcdef", "bd")); // 1
strtod
取double数值
char *ptr;
double ret = strtod("111.1agc", &ptr);
printf("%f,%s
", ret, ptr); // 111.100000,agc
运算符
算术运算符
+ - *
/ 实数相除得双精度浮点，整数相除得整数部分，负数相除向零靠拢
% ++ --
关系运算符
< <= > >= == !=
优先级，从上到下依次降低
!
算术运算符
< <= > >=
== !=
&&
||
=
逻辑运算符
逻辑与 a != b && 1 != 2
逻辑或 a != b || 1 == 2
逻辑非 !a 等价于 a == 0
逗号操作符
计算左操作表达式，不管它的返回值，整个表达式的返回值由最右边的操作表达式计算后的结果决定
int x = 42, y = 42;
printf("%i
", (x *= 2, y)); // 42
流程控制语句
if...else...
a>b?a:b
switch结构
char a = 'c';
switch (a)
{
case 'a': printf("a"); break;
case 'b': printf("b"); break;
default: printf("no"); break;
}
while(...){...}
do{...}while(...)
for (int i = 0; i < 100; i++) { }
for(sumk = 1, k = 1; k < 10; k++, sumk += k)
printf("\%5d\%5d\n", k, sumk);
break 立即跳出循环
continue 终止本次循环
输入输出语句
printf
常用的格式字符
d或者i
有符号十进制整数，long使用ld表示，long long使用lld表示
int a = 11111;
printf("%8d
", a); // 制定输出占8列
printf("%5d
", a);
c
用来输出字符
char a = 'a';
printf("%c
", a);
s
用来输出字符串
printf("%s
", "aa");
f
用来输出实型数据
默认小数位数6位
double a = 1;
printf("%f
", a); 1.000000
指定小数位数
double a = 1111;
printf("%0.10f
", a);
e
用来输出指数
double a = 1111;
printf("%e
", a); 1.111000e+03
printf("%0.2e
", a); 1.11e+03
o 用来输出8进制整数
x 用来表示16进制整数
u 用来表示无符号10进制整数
g 用来输出浮点数，自动选择f或者e，谁输出的长度短，就选谁
scanf
scanf("%d,%d", &a, &b); // 输入 1,2 这种格式获取数据
scanf("%d%d", &a, &b); // 输入 1 2 这种格式获取数据
putchar和getchar
输出字符
putchar('a');
输入字符
char a, b;
a = getchar();
b = getchar(); // 输入gd，然后按enter键
变量和函数的存储类别
变量的存储类别
局部变量的存储类别
auto变量
函数调用完毕自动释放变量的存储空间，局部变量默认都是auto变量，auto关键字可以省略
将变量存储在动态存储区
auto a = 1;
static变量
函数调用完毕后不销毁，保留原始值 static int a = 1;
将变量存储在静态存储区
register变量
某一变量读写频繁，可以定义成register将值存在cpu的寄存器中
目前系统可以自动完成这一功能
全局变量的存储类别
extern扩展全局变量作用域
void fn1() {
extern int a; // 将变量的作用域扩展到此处
printf("%d
", a);
}
int a = 1;
在其他c文件中，同样可以使用extern关键字，直接调用其他文件定义的全局变量
如果想限制其他文件访问此文件的全局变量，可以直接 static int a = 1;
这里的static关键字，仅仅用来限定作用域，不会改变存储区
函数的存储类别
默认是extern，此关键字可以省略不写
将作用域限定在当前文件，加static限定即可
指针
创建指针变量
int a = 1;
int *b = &a; // 创建指针变量，&a用来表示整型数据的地址
printf("%d
", *b); // 通过*b访问指针变量b对应的变量
指针变量在数组中的应用
int arr[] = { 1,2,3,4,5 };
int *p1 = arr, *p2 = &arr[0];
printf("%o
", p1); // 105374130
printf("%o
", p2); // 105374130
int *p = (int [2]){ 2, 4 }; // 指向数组的第一个元素
数组名代表数组首元素的地址，即 arr == &arr[0]
指针变量的加减运算
当指针指向数组元素时，指针变量的加减运算才有意义
地址加整数
int arr[] = { 1,2,3,4,5 };
int *p1 = &arr[0];
int *p2 = p1 + 1; // 访问数组的下个元素，+1 相当于加一个数组元素所占用的字节数
printf("%d
", *p2); // 2
指针变量十进制值 p1 -> 5241000 p2 -> 5241004
地址减地址
p2 - p1; // 1 表示p2对应的元素和p1对应的元素相隔的距离
地址加地址，无意义
利用指针快速遍历数组
int arr[] = { 1,2,3,4,5 }, *p;
for (p = arr; p < arr + 5; p++) {
printf("%d", *p);
}
c语言中访问数组的[]其实是一个语法糖，arr[i] 等价于 *(arr + i)，也就是说，p[i] 等价于 *(p + i)
使用技巧
*p++
*++p 先进行++运算，然后进行*计算
在二维数组中使用指针
int arr[][2] = { {1,2}, {3,4} };
printf("%d
", *(arr + 1)); // 9174020
printf("%d
", *(arr[0] + 1)); // 2
arr表示二维数组第一行的地址等价于arr[0]，arr[0]表示第一行第一列的地址等价于arr[0][0]
注意，arr 和 arr[0] 内存地址是一样的，但是数据类型不一样
int (*p2)[2] = arr; 代表一维数组，表示二维数组中行的指针
指针变量在字符串中的使用
字符串其实就是字符数组
char arr[] = "c language is so easy";
printf("%c
", *arr); // c 数组名代表字符串第一个字符的地址
使用指针表示字符串
char *arr = "c language is so easy"; // 最好加上const
printf("%s
", arr);
复制字符串
char *str = "c language is so easy", str1[50];
int i;
for ( i = 0; *(str + i) != ' '; i++) {
*(str1 + i) = *(str + i);
}
*(str1 + i) = ' ';
printf("%s
%s
", str, str1);
指针变量在函数中的使用
基本使用
int main()
{
int fn(int);
int (*p)(int) = fn; // 声明函数指针变量并赋值
printf("%d
", (*p)(1)); // (*p)(1) 和 p(1) 效果一样
return 0;
}
int fn(int a) {
return ++a;
}
函数作为另一个函数的参数
int main()
{
void fn1(int (*fun)(int));
int fn(int);
fn1(fn);
return 0;
}
int fn(int a) {
return ++a;
}
void fn1(int (*fun)(int)) {
printf("%d
", fun(2));
}
函数的返回值是指针
int main()
{
char *fn();
char *p = fn();
printf("%s
", p);
return 0;
}
char *fn() {
char *str = "c language is so easy";
return str;
}
指针变量在结构体的使用
结构体指针的使用
struct stu
{
int a;
};
struct stu demo = { 1 };
struct stu *p = &demo;
printf("%d
", demo.a); // 1
printf("%d
", (*p).a); // 1
printf("%d
", p->a); // 1
结构体指针数组的使用
struct stu arr[3] = { {1}, {2}, {3} }, *p;
for (p = arr; p < arr + 3; p++) {
printf("%d
", (*p).a);
}
指针的其他应用
指针数组
数组中的每一个元素可以是指针
char* arr[] = { "a", "b", "c" };
printf("%c
",**arr); // a
指向指针数据的指针变量
char* arr[] = { "a", "b", "c" }, **p;
for (int i = 0; i < 3; i++) {
p = arr + i;
printf("%s
", *p);
}
main函数的参数
int main(int length, char* params[])
{
for (int i = 0; i < length; i++) {
printf("%s%c", *(params + i), (i == (length- 1)?'
':' '));
}
return 0;
}
通过命令行输入 .ConsoleApplication1.exe 1 2 3 a b c
length得到的值是7，params就是参数的指针数组
动态内存分配
c语言的非静态局部变量存储在动态存储区，这个存储区称为栈
c语言允许用户自定义内存动态存储区，这个存储区称为堆，通过指针来引用，c提供下面的库函数来实现这一功能
需要导入#include<stdlib.h>
malloc函数
用来开辟动态存储区
malloc(100); // 创建100个字节的空间，返回的指针为void类型
calloc函数
用来创建50个4个字节长度的连续空间
calloc(50, 4); // 返回的指针为void类型
realloc函数
用来将开辟的动态存储区重新划分
void *p = calloc(50, 4);
realloc(p, 50); // 将p指向的存储区重新规划成50个字节大小的存储区，返回的指针为void类型
free函数
释放已经开辟的动态存储区
void *p = calloc(50, 4);
free(p); // 无返回值
注意
void类型的指针不能存储数据，使用之前必须重新分派类型，应当如下使用
int* p = (int*)malloc(100); // 简写，
使用demo
int* p = (int *)malloc(5 * sizeof(int));
for (int i = 0; i < 5; i++) {
scanf("%d", p + i);
}
for (int i = 0; i < 5; i++) {
if (*(p + i) < 10) {
printf("%d
", *(p + i));
}
}
typedef
typedef关键字用来给已知的数据类型取别名，用法如下
基本数据类型名替换
typedef int Integer;
Integer i = 111;
printf("%d
", i);
结构体取别名
typedef struct {
int i;
} test;
test i = { 1 };
printf("%d
", i.i);
数组取别名
typedef int arr[5];
arr test = { 1,2,3,4,5 };
printf("%d
", test[0]);
指针取别名
int arr[5] = { 1,2,3,4,5 };
typedef int* p;
p test = arr;
printf("%d
", *test);
函数指针取别名
int main()
{
void fn();
typedef void(*test)();
test f = fn;
f();
return 0;
}
void fn() { printf("%s
", "调用了"); }
文件操作
打开文件
文件缓冲区：每一个正在使用的文件都会自动开辟一个文件缓冲区，用来存放临时数据
指向文件的指针变量 FILE* f;
打开文件
FILE* f = fopen("F:\demo.txt", "r");
if (f == NULL) {
perror("Error");
exit(0); // 此函数是终止程序，需要 #include<stdlib.h>
}
printf("%d
", fclose(f));
权限控制
文本文件
r 只读，文件不存在则出错
w 只写，创建新文件
a 追加，文件不存在则出错
r+ 读写，文件不存在则出错
w+ 读写，创建新文件
a+ 读写，文件不存在则出错
二进制文件
rb 只读，文件不存在则出错
wb 只写，创建新文件
ab 追加，文件不存在则出错
rb+ ...
wb+ ...
ab+ ...
提示：带b的和不带b的区别，不带b的会把
转化成
和
标准流
系统已经定义了3个流的指针变量
标准输入流 stdin
标准输出流 stdout
标准出错输出流 stderr
关闭流
调用fclose函数可以将文件缓冲区中的数据输出到磁盘中，然后再撤销文件信息区
fclose(f);
读写字符
写字符fputc，简写 putc
FILE* f = fopen("F:\demo.txt", "w");
if (f == NULL) {
perror("Error");
exit(0);
}
printf("%d
", fputc('a', f)); // 写字符，成功则返回字符，不成功返回-1，即EOF
printf("%d
", fclose(f)); // 关闭文件流成功返回0，不成功返回-1，即EOF
读字符fgetc，简写 getc
FILE* f = fopen("F:\demo.txt", "r");
if (f == NULL) {
perror("Error");
exit(0);
}
printf("%d
", fgetc(f)); // 读字符，成功则返回字符，不成功返回-1，即EOF
printf("%d
", fclose(f));
复制文件
FILE* in = fopen("F:\demo.txt", "r");
FILE* out = fopen("F:\demo1.txt", "w");
if (in == NULL || out == NULL) {
perror("Error");
exit(0);
}
char ch = fgetc(in); // 读取输入流第一个字符
while (!feof(in)) { // 判断输入流是否已到末尾，等价于 while (ch != EOF)
fputc(ch, out);
ch = fgetc(in); // 读取下一个字符
}
fclose(in);
fclose(out);
读写字符串
写字符串fputs
FILE* f = fopen("F:\demo.txt", "w");
if (f == NULL) {
perror("Error");
exit(0);
}
fputs("c language is so easy", f); // 执行成功，返回0，不成功，返回EOF
fclose(f);
读取字符串fgets
FILE* f = fopen("F:\demo.txt", "r");
if (f == NULL) {
perror("Error");
exit(0);
}
char str[50];
fgets(str, 23, f); // 读取22个字符，并且存到str中，如果遇到换行符
或者EOF，就结束读取，其中
是会读到结果中的，执行成功返回地址，不成功返回NULL
fclose(f);
printf(str);
格式化读写字符串
格式化写
FILE* f = fopen("F:\demo.txt", "w");
if (f == NULL) {
perror("Error");
exit(0);
}
float i = 1; int j = 2;
fprintf(f, "%.2f, %d", i, j);
fclose(f);
格式化读
FILE* f = fopen("F:\demo.txt", "r");
if (f == NULL) {
perror("Error");
exit(0);
}
float i; int j;
fscanf(f, "%f, %d", &i, &j);
fclose(f);
printf("%f, %d
", i, j);
二进制方式读写数据
写数据fwrite
struct test
{
int i;
} t = { 1 };
FILE* f = fopen("F:\demo.dat", "wb");
if (f == NULL || fwrite(&t, sizeof(struct test), 1, f) != 1) { // fwrite函数返回值是读取数据的个数
perror("Error");
exit(0);
}
fclose(f);
读数据fread
struct test {
int i;
} t;
FILE* f = fopen("F:\demo.dat", "rb");
if (f == NULL || fread(&t, sizeof(struct test), 1, f) != 1) { // fread函数返回值是写数据的个数
perror("Error");
exit(0);
}
printf("%d
", t.i);
控制文件位置标记
将位置移动到开头
FILE* f = fopen("F:\demo.txt", "w+");
if (f == NULL) {
perror("Error");
exit(0);
}
fputs("c language is so easy", f);
char str[50];
rewind(f); // 将文件位置指针挪到开头
fgets(str, 23, f); // c language is so easy
printf(str);
fclose(f);
随意移动指针
以上面demo为例
SEEK_CUR
fseek(f, -5L, SEEK_CUR); 以当前位置为准将位置向左移动5个字节
fgets(str, 23, f); // " easy"
SEEK_SET
fseek(f, 5L, SEEK_SET); 以开始位置为准将位置向右移动5个字节
fgets(str, 23, f); // 'guage is so easy'
SEEK_END 表示结尾
获取文件当前指针位置
int i = ftell(f); // 相对于文件起始位置
if (i == -1L) { // 获取不到返回-1L
printf("error
");
}
else {
printf("%ld
", i);
}
检查错误
ferror函数
当调用各种输入输出函数时，如果出现错误ferror返回非0值
printf("%d
", ferror(f));
clearerr函数
当文件读写出错，要调用 clearerr(f); 清空文件读写错误标志