Let C语言通俗化

以下内容已省略main函数

输入/输出

输出

printf();
puts();
putchar();

例如，输出hello world

printf("hello world");

输出变量

输出整型的1

int var = 1;
printf("%d", var);

输出浮点型的1.0

float var = 1.0;
printf("%f", var);

输出字符型的a

char var = 'a';
printf("%c", var);

char var = 'a';
putchar(var);

输出字符串hello

char var[] = "hello";
printf("%s", var);

char var[] = "hello";
puts(var);

输出整型的1，宽度为5，右对齐

int var = 1;
printf("%5d", var);

输出整型的1，宽度为5，左对齐

int var = 1;
printf("%-5d", var);

输出整型的1，宽度为5，前补0

int var = 1;
printf("%05d", var);

输出整型的1，宽度为5，前补0，右对齐

int var = 1;
printf("%05d", var);

输出浮点型的1，精度为2

float var = 1.0;
printf("%.2f", var);

输出浮点型的1，精度为2，前补0

float var = 1.0;
printf("%0.2f", var);

输入

scanf();
gets();
getchar();

例如：

输入整型的1

int var;
scanf("%d", &var);

输入浮点型的1.0

float var;
scanf("%f", &var);

输入双精度的1.0

double var;
scanf("%lf", &var);

输入字符型的a

char var;
scanf("%c", &var);

char var;
var = getchar();

输入字符串hello

char var[10];
scanf("%s", var);

char var[10];
gets(var);

基本运算

加、减、乘、除、取余

1 + 2;      // 加法
1 - 2;      // 减法
1 * 2;      // 乘法
1 / 2;      // 除法
1 % 2;      // 取余

整数除法和浮点数除法

5 / 2;      // 整数除法，结果为2
5.0 / 2.0;      // 浮点数除法，结果为2.5

变量

声明

int var;

基本数据类型

• int 整型
• float 单精度浮点型
• double 双精度浮点型
• char 字符型
• bool 布尔型
• long 长整型
• short 短整型
• unsigned 无符号整型
• signed 有符号整型
• long long 长长整型

赋值

声明时，令var为1

int var = 1;

赋值为1

var = 1;

交换

设置一个缓存变量temp，将a的值赋给temp，然后将b的值赋给a，最后将temp的值赋给b。

例如，交换a和b的值

int a = 1, b = 2, temp;
temp = a;
a = b;
b = temp;

运算

int a = 1, b = 2;
int c = a + b;      // 加法
int c = a - b;      // 减法
int c = a * b;      // 乘法
int c = a / b;      // 除法
int c = a % b;      // 取余

整数除法和浮点数除法

int a = 5, b = 2;
float c = 5.0, d = 2.0;
int result1 = a / b;      // 整数除法，结果为2
float result2 = c / d;      // 浮点数除法，结果为2.5

实例

判断奇偶数

if (a % 2 == 0) {printf("a是偶数");
} else {printf("a是奇数");
}

逻辑

运算符	描述
a && b	a和b都为真时为真
a || b	a或b为真时为真
!a	a为假时为真
a < b	a小于b时为真
a > b	a大于b时为真
a <= b	a小于等于b时为真
a >= b	a大于等于b时为真
a == b	a等于b时为真
a != b	a不等于b时为真

实例

自然语言	语句实现
1 <= a <= 2	1 <= a && a <= 2
a != 1 且 a != 2	a != 1 && a != 2
a >1 或 a < -1	a > 1 || a < -1

自增/自减

int a = 1;
int b = a++;      // b = 1, a = 2
int b = ++a;      // b = 2, a = 2
int b = a--;      // b = 2, a = 1
int b = --a;      // b = 1, a = 1

判断

if

单分支

if (condition) {// do something
}

如果满足condition，则执行do something的代码，否则不执行。

如果否则

if (condition) {// do something
} else {// do something else
}

如果满足condition，则执行do something的代码，否则执行do something else的代码。

如果，否则如果，最后否则

if (condition1) {// do something
} else if (condition2) {// do something else
} else {// do something else
}

如果满足condition1，则执行do something的代码，否则如果满足condition2，则执行do something else的代码，否则执行最后的代码。

实例

如果a大于b，输出a > b，否则如果a小于b，输出a < b，否则输出a = b

if (a > b) {printf("a > b");
} else if (a < b) {printf("a < b");
} else {printf("a = b");
}

switch

switch语句用于多分支选择，case后面跟要判断的值，break用于跳出switch语句，如果没有break，则会继续执行下一个case的代码。
default用于处理所有case都不满足的情况。

switch (a) {case 1:// do somethingbreak;case 2:// do somethingbreak;default:// do something
}

传入a的值，如果a等于1，执行第一个case的代码，如果a等于2，执行第二个case的代码，如果a不等于1和2，执行default的代码。

实例

如果a等于1，输出a = 1，否则如果a等于2，输出a = 2，否则输出a != 1 && a != 2

switch (a) {case 1:printf("a = 1");break;case 2:printf("a = 2");break;default:printf("a != 1 && a != 2");
}

三目运算符

如果a大于b，输出a > b，否则输出a < b

printf("%s", a > b ? "a > b" : "a < b");

循环

for

for (init; condition; increment) {// do something
}

设置一个初始值init，当condition为真时，执行循环体，然后执行increment，再判断condition是否为真，如果为真，则继续执行循环体，否则退出循环。

实例

从1到10，输出1 2 3 4 5 6 7 8 9 10

for (int i = 1; i <= 10; i++) {printf("%d ", i);
}

从1到10，输出1 2 3 4 5 6 7 8 9 10，每行输出5个数字

for (int i = 1, k = 0; i <= 10; i++) {printf("%d ", i);k++;if (k == 5) {printf("\n");k = 0;}
}

从1到10，输出1 2 3 4 5 6 7 8 9 10，每个数字之间用空格隔开。

for (int i = 1; i <= 10; i++) {printf("%d", i);printf(" ");
}

从1到10，输出1 2 3 4 5 6 7 8 9 10，每个数字之间用空格隔开，最后一个数字后面没有空格

for (int i = 1; i <= 10; i++) {if(i == 1) {printf("%d", i);} else {printf(" %d", i);}
}

求阶乘，例如，输入5，输出120

int n = 5;
int result = 1;
for (int i = 1; i <= n; i++) {result *= i;
}
printf("%d", result);

while

while (condition) {// do something
}

当condition为真时，执行循环体

计算每一位数的和

例如，输入12345，输出15

int n = 12345;
int sum = 0;
while (n > 0) {sum += n % 10;n /= 10;
}
printf("%d", sum);

计算每一位数的积

例如，输入12345，输出120

int n = 12345;
int product = 1;
while (n > 0) {product *= n % 10;n /= 10;
}
printf("%d", product);

无限制输入

例如，输入1 2 3 4 5，输出15

int n, sum = 0;
while (scanf("%d", &n) != EOF) {sum += n;
}
printf("%d", sum);

do while

do {// do something
} while (condition);

先执行一次循环体，然后判断condition是否为真，如果为真，则继续执行循环体，否则退出循环。

实例

统计十进制的位数

int num = 0, cnt = 0;
do {cnt = cnt + 1;			// 计数器+1num /= 10;		// 去除已统计的数
} while (num > 0);

函数

构造

int function_name(int var1, int var2) {// do somethingreturn result;
}

定义一个function_name函数，接受两个整型参数var1和var2，返回一个整型结果result。

调用

int result = function_name(var1, var2);

调用function_name函数，传入参数var1和var2，返回结果赋值给result。

实例

例如，定义一个函数add，接受两个整型参数a和b，返回它们的和

int add(int a, int b) {return a + b;
}int main() {int a = 1, b = 2;int result = add(a, b);printf("%d", result);return 0;
}

数组

声明

int arr1[10];      // 声明一个长度为10的整型数组
int arr2[10] = {1, 2, 3, 4, 5};      // 声明一个长度为10的整型数组，并初始化前5个元素
int arr3[10] = {0};      // 声明一个长度为10的整型数组，并初始化所有元素为0
int arr4[] = {1, 2, 3, 4, 5};      // 声明一个整型数组，并初始化前5个元素，长度自动计算int arr5[10][10];      // 声明一个10x10的整型二维数组
int arr6[10][10] = {0};      // 声明一个10x10的整型二维数组，并初始化所有元素为0
int arr7[10][10] = {{1, 2, 3}, {4, 5, 6}};      // 声明一个10x10的整型二维数组，并初始化前两行
int arr8[][10] = {{1, 2, 3}, {4, 5, 6}};      // 声明一个整型二维数组，并初始化前两行，长度自动计算

字符数组和字符串

两者的差别仅在最后面是否以0（\0）结尾。
字符串以0（\0）结尾，字符数组则不是

访问

arr[0] = 1;      // 访问一维数组的第一个元素
arr[1] = 2;      // 访问一维数组的第二个元素arr[0][0] = 1;      // 访问二维数组的第一个元素
arr[0][1] = 2;      // 访问二维数组的第二个元素

遍历

一维数组

从0号位开始遍历到4号位

int arr[10] = {1, 2, 3, 4, 5};
for (int i = 0; i < 5; i++) {printf("%d ", arr[i]);
}

二维数组

从第一行开始遍历到第二行

int arr[10][10] = {{1, 2, 3}, {4, 5, 6}};
for (int i = 0; i < 2; i++) {for (int j = 0; j < 3; j++) {printf("%d ", arr[i][j]);}
}

指针

声明

int *p;      // 声明一个整型指针
char *p;      // 声明一个字符型指针
float *p;      // 声明一个浮点型指针
double *p;      // 声明一个双精度浮点型指针

赋值

使p指向变量a所在的位置

此时，我们要使用&符号来获取变量a的地址

int a = 1;
int *p = &a;      // 将a的地址赋值给指针p

访问

使用*符号来访问指针p指向的值

int a = 1;
int *p = &a;      // 将a的地址赋值给指针p
printf("%d", *p);      // 访问指针p指向的值
*p = 2;      // 修改指针p指向的值   
printf("%d", a);      // 输出a的值

malloc（动态内存分配）

int *p = (int *)malloc(sizeof(int) * 10);      // 动态分配10个整型的内存