C 语言教程讲义
Loon_zz
1 C 语言概述 ······························································································································1
1.1 C语言的发展过程········································································································1
1.2 当代最优秀的程序设计语言 ·······················································································1
1.3 C语言版本 ···················································································································1
1.4 C语言的特点 ···············································································································1
1.5 面向对象的程序设计语言···························································································2
1.6 C和C++ ···················································································································2
1.7 简单的C程序介绍·······································································································2
1.8 输入和输出函数 ··········································································································4
1.9 C源程序的结构特点····································································································5
1.10 书写程序时应遵循的规则 ·························································································5
1.11 C语言的字符集··········································································································5
1.12 C语言词汇 ·················································································································5
1.13 Turbo C 2.0 集成开发环境的使用··············································································7
1.13.1 Turbo C 2.0 简介和启动···················································································7
1.13.2 Turbo C 2.0 集成开发环境···············································································7
1.13.3 File 菜单 ···········································································································8
1.13.4 Edit 菜单···········································································································9
1.13.5 Run 菜单·········································································································10
1.13.6 Compile 菜单··································································································11
1.13.7 Project 菜单 ····································································································12
1.13.8 Options 菜单···································································································13
1.13.9 Debug 菜单·····································································································17
1.13.10 Break/watch 菜单··························································································18
1.13.11 Turbo C 2.0 的配置文件 ···············································································19
2 程序的灵魂—算法 ················································································································20
2.1 算法的概念 ················································································································20
2.2 简单算法举例 ············································································································20
2.3 算法的特性 ················································································································23
2.4 怎样表示一个算法·····································································································23
2.4.1 用自然语言表示算法 ······················································································23
2.4.2 用流程图表示算法··························································································23
2.4.3 三种基本结构和改进的流程图 ······································································27
2.4.4
用 N-S 流程图表示算法··················································································28
2.4.5 用伪代码表示算法··························································································29
2.4.6 用计算机语言表示算法 ··················································································30
2.5 结构化程序设计方法·································································································30
3 数据类型、运算符与表达式·································································································31
3.1 C语言的数据类型······································································································31
3.2 常量与变量 ················································································································32
3.2.1 常量和符号常量······························································································32
3.2.2 变量 ·················································································································33
3.3 整型数据 ····················································································································33
3.3.1 整型常量的表示方法 ······················································································33
3.3.2 整型变量 ·········································································································34
3.4 实型数据 ····················································································································37
3.4.1 实型常量的表示方法 ······················································································37
3.4.2 实型变量 ·········································································································38
3.4.3 实型常数的类型······························································································39
3.5 字符型数据 ················································································································39
3.5.1 字符常量 ·········································································································39
3.5.2 转义字符 ·········································································································40
3.5.3 字符变量 ·········································································································41
3.5.4 字符数据在内存中的存储形式及使用方法 ···················································41
3.5.5 字符串常量······································································································42
3.6 变量赋初值 ················································································································42
3.7 各类数值型数据之间的混合运算 ·············································································43
3.8 算术运算符和算术表达式·························································································44
3.8.1 C 运算符简介···································································································45
3.8.2 算术运算符和算术表达式 ··············································································45
3.9 赋值运算符和赋值表达式·························································································47
3.10 逗号运算符和逗号表达式 ·······················································································49
3.11 小结 ··························································································································49
3.11.1 C的数据类型·································································································49
3.11.2 基本类型的分类及特点 ················································································49
3.11.3 常量后缀········································································································50
3.11.4 常量类型········································································································50
3.11.5 数据类型转换································································································50
3.11.6 运算符优先级和结合性 ················································································50
3.11.7 表达式············································································································50
4 最简单的 C 程序设计—顺序程序设计 ················································································51
4.1 C语句概述 ·················································································································51
4.2 赋值语句 ····················································································································52
4.3 数据输入输出的概念及在 C 语言中的实现 ·····························································53
4.4 字符数据的输入输出·································································································54
4.4.1 putchar 函数(字符输出函数) ·····································································54
4.4.2 getchar
函数(键盘输入函数)·······································································54
4.5 格式输入与输出 ········································································································55
4.5.1 printf 函数(格式输出函数) ·········································································55
4.5.2 scanf 函数(格式输入函数)···············································································58
4.6 顺序结构程序设计举例·····························································································62
5 分支结构程序························································································································64
5.1 关系运算符和表达式·································································································64
5.1.1 关系运算符及其优先次序 ··············································································64
5.1.2 关系表达式······································································································64
5.2 逻辑运算符和表达式·································································································65
5.2.1 逻辑运算符极其优先次序 ··············································································65
5.2.2 逻辑运算的值··································································································65
5.2.3 逻辑表达式······································································································66
5.3 if 语句··························································································································67
5.3.1 if 语句的三种形式 ···························································································67
5.3.2 if 语句的嵌套 ···································································································70
5.3.3 条件运算符和条件表达式 ··············································································72
5.4 switch 语句··················································································································73
5.5 程序举例 ····················································································································74
6 循环控制································································································································76
6.1 概述····························································································································76
6.2 goto 语句以及用 goto 语句构成循环 ·········································································76
6.3 while 语句 ···················································································································77
6.4 do-while 语句 ··············································································································79
6.5 for 语句 ·······················································································································81
6.6 循环的嵌套 ················································································································84
6.7 几种循环的比较 ········································································································84
6.8 break 和 continue 语句 ································································································84
6.8.1 break 语句·········································································································84
6.8.2 continue 语句···································································································85
6.9 程序举例 ····················································································································86
7 数组 ·······································································································································89
7.1 一维数组的定义和引用·····························································································89
7.1.1 一维数组的定义方式 ······················································································89
7.1.2 一维数组元素的引用 ······················································································90
7.1.3 一维数组的初始化··························································································91
7.1.4 一维数组程序举例··························································································92
7.2 二维数组的定义和引用·····························································································93
7.2.1 二维数组的定义······························································································93
7.2.2 二维数组元素的引用 ······················································································94
7.2.3 二维数组的初始化··························································································95
7.2.4 二维数组程序举例··························································································96
7.3 字符数组 ····················································································································96
7.3.1 字符数组的定义
······························································································96
7.3.2 字符数组的初始化··························································································97
7.3.3 字符数组的引用······························································································97
7.3.4 字符串和字符串结束标志 ··············································································98
7.3.5 字符数组的输入输出 ······················································································98
7.3.6 字符串处理函数······························································································99
7.4 程序举例 ··················································································································102
7.5 本章小结 ··················································································································105
8 函 数····································································································································106
8.1 概述··························································································································106
8.2 函数定义的一般形式·······························································································107
8.3 函数的参数和函数的值···························································································109
8.3.1 形式参数和实际参数 ····················································································109
8.3.2 函数的返回值································································································110
8.4 函数的调用 ··············································································································111
8.4.1 函数调用的一般形式 ····················································································111
8.4.2 函数调用的方式····························································································111
8.4.3 被调用函数的声明和函数原型 ····································································112
8.5 函数的嵌套调用 ······································································································113
8.6 函数的递归调用 ······································································································114
8.7 数组作为函数参数···································································································117
8.8 局部变量和全局变量·······························································································122
8.8.1 局部变量 ·······································································································122
8.8.2 全局变量 ·······································································································123
8.9 变量的存储类别 ······································································································125
8.9.1 动态存储方式与静态动态存储方式·····························································125
8.9.2 auto 变量·········································································································125
8.9.3 用 static 声明局部变量··················································································126
8.9.4 register 变量····································································································127
8.9.5 用 extern 声明外部变量 ················································································127
9 预处理命令··························································································································129
9.1 概述··························································································································129
9.2 宏定义 ······················································································································129
9.2.1 无参宏定义····································································································129
9.2.2 带参宏定义····································································································132
9.3 文件包含 ··················································································································136
9.4 条件编译 ··················································································································136
9.5 本章小结 ··················································································································138
10 指针 ·····································································································································140
10.1 地址指针的基本概念·····························································································140
10.2 变量的指针和指向变量的指针变量 ·····································································141
10.2.1 定义一个指针变量······················································································141
10.2.2 指针变量的引用··························································································142
10.2.3 指针变量作为函数参数
··············································································145
10.2.4 指针变量几个问题的进一步说明·······························································149
10.3 数组指针和指向数组的指针变量 ·········································································151
10.3.1 指向数组元素的指针··················································································151
10.3.2 通过指针引用数组元素 ··············································································153
10.3.3 数组名作函数参数······················································································155
10.3.4 指向多维数组的指针和指针变量·······························································161
10.4 字符串的指针指向字符串的针指变量··································································164
10.4.1 字符串的表示形式······················································································164
10.4.2 使用字符串指针变量与字符数组的区别···················································167
10.5 函数指针变量 ········································································································168
10.6 指针型函数 ············································································································169
10.7 指针数组和指向指针的指针 ·················································································170
10.7.1 指针数组的概念··························································································170
- 1
- 2
- 3
- 4
- 5
- 6
前往页