[关闭]
@EncyKe 2017-03-10T06:42:57.000000Z 字数 6364 阅读 2753

手册:C

#手册 C



1. 简介

  1. // 头文件;
  2. #inclue<stdio.h>
  3. // 主函数;int 是主函数类型;
  4. int main()
  5. {
  6. // printf() 是格式输出函数;
  7. printf("文本");
  8. // return 是函数返回值;
  9. return 0;
  10. }
头文件
通知 C 语言编译系统在对 C 程序进行正式编译之前需做一些预处理工作;
主函数
一个 C 程序有且只有一个主函数,即 main() 函数,C 程序就是执行主函数里的代码,主函数就是 C 语言中的唯一入口;

2. 基础规范

2.1. 编码规范

2.2. 标识符

标识符
是变量或者函数的名字。

2.3. 注释语句

  1. /* 多行注释 */
  2. // 单行注释

3. 变量与常量

3.1. 变量的存储方式

静态存储方式
指在程序运行期间分配固定的存储空间的方式。静态存储区中存放了在整个程序执行过程中都存在的变量,如全局变量。
动态存储方式
指在程序运行期间根据需要进行动态的分配存储空间的方式。动态存储区中存放的变量是根据程序运行的需要而建立和释放的,通常包括:函数形式参数自动变量、函数调用时的现场保护返回地址等。

3.2. 变量的存储类别

自动 auto
用关键字 auto 定义的变量为自动变量,auto 可省略,隐含定为“自动存储类别”,属于动态存储方式。
静态 static

static 修饰的为静态变量,如果定义在函数内部的,称之为静态局部变量;如果定义在函数外部,称之为静态外部变量。

  • 静态局部变量属于静态存储类别,在静态存储区内分配存储单元,在程序整个运行期间都不释放;静态局部变量在编译时赋初值,即只赋初值一次;如果在定义局部变量时不赋初值的话,则对静态局部变量来说,编译时自动赋初值 0(对数值型变量)或空字符(对字符变量)。
寄存器 register

为了提高效率,C 语言允许将局部变量得值放在 CPU 中的寄存器中,这种变量叫“寄存器变量”,用关键字 register 作声明。

  • 只有局部自动变量和形式参数可以作为寄存器变量;一个计算机系统中的寄存器数目有限,不能定义任意多个寄存器变量;局部静态变量不能定义为寄存器变量。
外部 extern
用 extern 声明的的变量是外部变量,外部变量的意义是某函数可以调用在该函数之后定义的变量。

3.3. 常量

语法:

  1. #define 标识符 常量值

4. 数据类型

基本数据类型 说明 字节 应用 示例
char 字符型 1 用于存储单个字符 char sex = 'M';
int 整型 2 用于存储整数 int height = 18;
float 单精度浮点型 4 用于存储小数 float price = 11.1;
double 双精度浮点型 8 用于存储位数更多的小数 double pi = 3.1415926;
整型数据类型 说明 字节 取值范围
int 整型 2 ~
short int / short 短整型 2 ~
long int / long 整型 4 ~
unsigned int 无符号整型 2 0 ~
unsigned short int / unsigned short 无符号短整型 2 0 ~
unsigned long int / unsigned long 无符号长整型 4 0 ~

4.1. 自动类型转换

4.2. 强制类型转换

语法:

  1. (数据类型)变量/(表达式);

5. 运算符

5.1. 算术运算符

名称 算术运算符号 举例
加法运算符 + 2 + 10;
减法运算符 - 10 - 3;
乘法运算符 * 2 * 10;
除法运算符 / 30 / 10;
求余(模)运算符 % 24 % 7;
自增运算符 ++ i++;
自减运算符 -- i--;
自增自减运算表达式 说明
先运算,再取值
++a a 自增 1 后再取值
--a a 自减 1 后再取值
先取值,再运算
a++ a 取值后,再自增 1
a-- a 取值后,再自减 1

5.2. 赋值运算符

5.3. 关系运算符

关系运算符 意义 举例 结果
> 大于 10 > 5; 1
>= 大于等于 10 >= 10; 1
< 小于 10 < 5; 0
<= 小于等于 10 <= 10; 1
== 等于 10 == 5; 0
!= 不等于 10 != 5; 1

5.4. 逻辑运算符

逻辑运算符 意义 举例 结果
&& 逻辑与 0 && 1; 0
|| 逻辑或 0 || 1; 1
! 逻辑非 !0; 1

5.5. 三目运算符

语法:

  1. 表达式1 ? 表达式2 : 表达式3;

5.6. 运算符优先级

优先级 运算符
1 ()
2 !, +(正), -(负), ++, --
3 *, /, %
4 +(加), -(减)
5 <, <=, >=, >
6 ==, !=
7 &&
8 ||
9 ?:
10 =, +=, -=, *=, /=, %=

6. 语句

6.0. 格式化输出语句

语法:

  1. printf("输出格式符",输出项);
常用格式符 说明 举例 结果
%d 带符号十进制整数 int a = 10; printf("%d", a); 10
%c 单个字符 char x = 'a'; printf("%c", x); a
%s 字符串 printf("%s", "FooBar"); FooBar
%f 6 位小数 float a = 1.23; printf("%f", a); 1.230000

6.1. 判断语句

  1. if(){...}

或者——

  1. if(){...}
  2. else{...}

或者——

  1. if(){...}
  2. else if(){...}
  3. else{...}

或者——

  1. if()
  2. {
  3. if(){...}
  4. else if(){...}
  5. else{...}
  6. }
  7. else
  8. {
  9. ...
  10. }

或者使用 switch——

  1. switch(变量){
  2. case 判断:
  3. ...
  4. break;
  5. case 判断:
  6. ...
  7. break;
  8. default: // 可以省略,位置可变
  9. ...
  10. }

6.2. 循环语句

  1. while(){...}

或者——

  1. do{...}while()

或者——

  1. for(赋值; 判断; 步进){...}
  2. // 三种表达式中同种若有多个,以,隔开

6.3. break 语句

  1. break

6.4. continue 语句

  1. continue

6.5. goto 语句

  1. LOOP: if(){...}
  2. goto LOOP;

7. 函数

7.1. 定义

声明语法:

  1. 数据类型 函数名(参数){
  2. ...
  3. return (表达式);
  4. }

先行声明语法:

  1. // 置于 main 函数之前
  2. 数据类型 函数名(参数);

7.2. 调用

语法:

  1. 函数名(参数);

7.3. 返回

语法:

  1. return (表达式);
void 函数
无返回值的函数,void 函数中若有 return 语句,只能是 return;

7.4. 递归

递归
指一个函数在其函数体内调用其自身。执行递归函数将反复调用其自身,每调用一次就进入新的一层;

7.5. 内部函数

语法:

  1. static 数据类型 函数名(参数)

7.6. 外部函数

语法:

  1. extern 数据类型 函数名(参数)

8. 数组

8.0. 数组声明

声明:

  1. 数据类型 数组名称[长度];

初始化:

  1. 数据类型 数组名称[长度n] = {元素1,元素2…元素n};
  2. // 或者——
  3. 数据类型 数组名称[] = {元素1,元素2…元素n};
  4. // 或者——
  5. 数据类型 数组名称[长度n]; 数组名称[0] = 元素1; 数组名称[1] = 元素2; 数组名称[n] = 元素n;

获取:

  1. 数组名称[元素所对应下标];

8.1. 传入参数

数组可作为参数传递,可以整个数组传递:函数(数组名),也可单独传递一个数组元素:函数(数组名[i]);作为函数实参传递时,数组元素类型必须与形参数据类型一致。

8.2. 冒泡排序程序

示例:

  1. #include <stdio.h>
  2. int main()
  3. {
  4. double arr[]={1.78, 1.77, 1.82, 1.79, 1.85, 1.75, 1.86, 1.77, 1.81, 1.80};
  5. int i,j;
  6. printf("\n************排队前*************\n");
  7. for(i=0;i<10;i++)
  8. {
  9. if(i != 9)
  10. printf("%.2f, ", arr[i]);
  11. //%.2f表示小数点后精确到两位
  12. else
  13. printf("%.2f", arr[i]);
  14. //%.2f表示小数点后精确到两位
  15. }
  16. for(i=8; i>=0; i--)
  17. {
  18. for(j=0;j<=i;j++)
  19. {
  20. if(arr[j]>arr[j+1])
  21. //当前面的数比后面的数大时
  22. {
  23. double temp;
  24. //定义临时变量temp
  25. temp = arr[j];
  26. //将前面的数赋值给temp
  27. arr[j] = arr[j+1];
  28. //前后之数颠倒位置
  29. arr[j+1]=temp;
  30. //将较大的数放在后面
  31. }
  32. }
  33. }
  34. printf("\n************排队后*************\n");
  35. for(i=0;i<10;i++)
  36. {
  37. if(i != 9)
  38. printf("%.2f, ", arr[i]);
  39. //%.2f表示小数点后精确到两位
  40. else
  41. printf("%.2f", arr[i]);
  42. //%.2f表示小数点后精确到两位
  43. }
  44. return 0;
  45. }

8.3. 查找数组中的值

示例:

  1. #include <stdio.h>
  2. int getIndex(int arr[5],int value)
  3. {
  4. int i;
  5. int index;
  6. for(i=0;i<5;i++)
  7. {
  8. if(arr[i]==value)
  9. {
  10. index=i;
  11. break;
  12. }
  13. }
  14. return index;
  15. }
  16. int main()
  17. {
  18. int arr[5]={3,12,9,8,6};
  19. int value = 8;
  20. int index = getIndex(arr, value);
  21. if(index!=-1)
  22. {
  23. printf("%d在数组中存在,下标为:%d\n",value,index);
  24. }
  25. else
  26. {
  27. printf("%d在数组中不存在。\n",value);
  28. }
  29. return 0;
  30. }

8.4. 多维数组

声明:

  1. 数据类型 数组名称[常量表达式1][常量表达式2]...[常量表达式n];

初始化:

  1. 数据类型 数组名称[常量表达式1][常量表达式2]...[常量表达式n
  2. // 或者——
  3. 数据类型 数组名称[常量表达式1][常量表达式2]...[常量表达式n]; 数组名称[下标1][下标2]...[下标n] = 值;
多维数组 第 0 列 第 1 列 第 2 列
第 0 行 num[0][0]=1 num[0][1]=2 num[0][2]=3
第 1 行 num[1][0]=4 num[1][1]=5 num[1][2]=6
第 2 行 num[2][0]=7 num[2][1]=8 num[2][2]=9

9. 字符串

9.1. 字符串变量

声明语法:

  1. char 字符串名称[长度] = "字符串值";
  2. // 或者——
  3. char 字符串名称[长度] = {'字符1','字符2',...,'字符n','\0'};

输出语法:

  1. printf(“%s”,字符数组名字);
  2. // 或者——
  3. puts(字符数组名字);

9.2. 字符串函数

函数格式 说明
strlen(s) 获取字符串的长度(单位字节)
strcmp(s1, s2) 比较字符串
strcpy(s1, s2) 拷贝字符串
strcat(s1, s2) 字符串拼接
atoi(s1) 字符串转为整数

附:参考

添加新批注
在作者公开此批注前,只有你和作者可见。
回复批注