C语言从放弃到入门

重新了解C语言

数据类型大小

编译器在给每个不同数据类型分配内存空间大小时与电脑所装操作系统位数(32位/64位)无关,与所用的编译器有关.

内存的分配由编译器决定的而与运行的环境无关.

编译器与语言标准

各个编译器对C语言的标准不一样,不同的编译器对C语言标准的支持不一样,有的编译器仅支持C89标准,而有的编译器能支持C99标准.
gcc编译器对C语言支持得很好,如下程序,使用gcc编译器可以编译并运行,但用一些其他的编译器便无法运行.

#include <stdio.h>
int main() 
{
	int a[0];
	printf("hello world!\n");
}

C89不支持 //注释.
不同编译器对C语言标准不一样,而且各个编译器对C语言的标准有扩展.

C语言可以做的事情

1.描述算法
2.操作系统开发
3.桌面软件
4.Web服务器,网络编程
5.游戏开发
6.开发编译器
7.数据库编程
8.实现新的语言
9.图形编程

计算机基本原理

计算机的基本组成

图灵原理与冯·诺依曼结构

程序储存原理

可执行文件是怎么生成的

程序存储方式

编译

链接

实验

1.编写以下代码

/*file : test.c*/
#include <stdio.h>
int a = 3;
int b = 4;
int c;
int main() 
{
	c = a + b;
}

2.通过gcc编译器执行以下命令编译成汇编文件

gcc -S -o test.s test.c

3.打开目录下生成的test.s汇编文件,可以看到入口main函数,各个变量的定义声明和内存偏移和指令.

4.通过gcc编译器执行以下命令编译成目标文件

gcc -c -o test.o test.s

编译完成后生成目标文件,打开该文件全是二进制代码.

5.通过gcc编译器执行以下命令链接成可执行文件

gcc -c -o test.exe test.o

6.编译完成后即可运行.

程序的运行

1.二进制文件储存在外部储存器.
2.当程序加载时从外部存储器将程序拷贝到内存区域中.
3.CPU中的控制中的指针指向程序的第一条指令,然后送到运算器依次执行.

程序的安装

1.裸机系统的程序烧写在FLASH
2.操作系统的程序由文件系统进行管理,安装在某一目录

什么是未定义行为

简单地说，未定义行为是指C语言标准未做规定的行为。编译器可能不会报错，但是这些行为编译器会自行处理，所以不同的编译器会出现不同的结果，什么都有可能发生，这是一个极大的隐患，所以我们应该尽量避免这种情况的发生。

C语言重新入门

标识符

1.用来标识程序中某个对象的名字.
2.标识符只能以数字,字母,下划线组成.
3.第一个必须是字母或下划线.
4.标识符长度.C89-31个有效字符.C99-63个有效字符.
5.标识符大小写敏感.
6.尽量不要以下划线开头(编译系统专用).

关键字

1.C语言保留的一些特定意义的标识符.
2.这些关键字被编译系统本身使用,用户不能再使用.
3.C89有32个关键字,C99新增5个关键字.

分类

1.数据类型关键字

char
int
double
short
long
float
signed
unsigned
struct
union
enum
void

2.控制语句关键字

if
else
switch
default
while
do
break
continue
for
return
goto

3.储存类型关键字

auto
register
static
extern

4.其他关键字

const
sizeof
typedef
volatile

5.C99新增关键字

_Bool
_Complex
Imaginary
inline
restrict

6.其他编译器扩展关键字

far
near
bit
sbit
sfr
sfr16
data
bdata
idata
pdata
xdata
code
interrupt
reetrant
using
_irq
__svc_indirect
…

预定义标识符

C语言系统中预先定义的标识符
1.系统类库名.
2.系统常量名(func/FILE).
3.系统函数名(printf/scanf).

预定义标识符和关键字类似,但不是关键字.
与宏定义不同,预定义标识符遵循代码块作用域规则.
用户可以把预定义标识符作为普通标识符使用,但会混淆违背系统规定的意愿,使用不当甚至会出错.

常量

在程序不能被改变的量称为常量.

常量的分类

1.直接常量

整型 / 字符型 / 浮点型 / 符号常量

2.标识符

变量名 / 函数名 / 数组名 / 文件名 / 类型名的有效字符序列

3.符号常量

宏

变量

可以被改变和重复赋值的量称为变量.

变量的特点

1.在运行过程中值可以改变.
2.有自己的类型,名字.
3.在内存中有自己的存储空间.
4.程序编译时会给每个变量分配空间互位置.
5.不同类型的变量在内存中占用的空间大小不同.

二进制计数及其转换

计算机内部数据都是采用二进制储存.
二进制满二进一.
C语言无法表示二进制数,可以通过移位表示.

int main() {
	 int a = 10;//十进制数
	 int b = 0XAB;//十六进制数
	 int c = 0123;//八进制转十进制
	 int d = 0x01 << 1;//通过移位表示二进制
}

二进制转十进制

• 除二取余法

十进制转二进制

• 乘二取整法

十进制转八进制

• 除八取余法

八进制换十进制

• 乘八取整法

十进制转十六进制

• 除十六取余法

十六进制转十进制

• 乘16取整法

数据在内存中的表示

原码 - 反码 - 补码

在计算机中数据分为有符号数和无符号数
无符号数中的所有位来表示数据.
有符号数的最高位表示符号位,正负 0表示正数,1表示负数.

原码

有符号数的原码
1 >>> 0000 0001
-1>>> 1000 0001

反码

正数的反码是其本身
负数的反码最高位符号位保持不变其余取反
原码 -1 >>> 1000 0001
反码 -1 >>> 1111 1110

补码

正数的补码是其本身
负数的补码最高位不变,其余的取反加一
原码 -1 >>> 1000 0001
补码 -1 >>> 1111 1111

补码转原码
先减一,再取反,或者做一次补码运算.

有符号数和无符号数

• 区别
  有符号数最高位表示正负符号.
  无符号数数据范围和有符号数数据范围不同.
• 无符号数和有符号数比较大小或进行运算
  当表达式中有无符号数和有符号数时,所有的操作数都自动转换为无符号类型.

int main() {
	unsigned int a = -10;
	signed int b = 5;
	if(a > b) {
		printf("a > b\n");
	}
	else if(b > a) {
		printf("b > a\n");
	}
}
//运行结果为
a > b
//将a以无符号的形式打印会出现一个很大的值
//printf("a = %u\n",a);

• 有符号数和无符号数的边界轮回问题
  假设数据为字符类型 数据范围为 -128~127

-128-1结果为 127
127+1结果为 -128
+0 >>> 0000 0000
-0 没有-0,最小的数为 -128 >>> 1000 0000

大端模式和小端模式

• 大端模式:高地址放高字节,低地址放低字节.
• 小端模式:高地址放低字节,低地址放高字节.

大端模式的1在内存中中
高地址------------低地址
0X00-0X00–0X00-0X01

小端模式的1在内存中中
高地址------------低地址
0X01–0X00–0X00-0X00

//判断当前系统是大端模式还是小端模式
int main() {
	union check 
	{
		int i;
		char ch;
	}c;
	c.i = 1;
	if(c.ch == 1)
		printf("小端模式");
	else
		printf("大端模式");
}

需要注意的问题

• 浮点数只有有符号数
• 边界轮回问题
• 边界判断问题

/* 边界判断问题 */
int main() {
	for(unsigned char i = 0;i >= 0 ;i--)
	printf("%d\n",i);
} 
//该程序将死循环

程序的调试

int main() {
	printf("%s\n",__func__);//打印当前函数
	printf("%s\n",__FILE__);//打印函数所在文件
	printf("%d\n",__LINE__);//打印当前行
	#line 200 //指定下一行的函数为200
	printf("%d\n",__LINE__);//打印出200
	printf("%s\n",__DATE__);//打印编译时的日期
	printf("%s\n",__TIME__);//打印编译时的时间
}

C语言数据类型

后缀
数字后面加 L 或 l 表示长整型
数字后面加 U 或 u 表示无符号型
数字后面加 UL, LU, ul, lu 表示无符号长整型

int 默认为 signed int
long long a; — long long int a; ---- signed long long int a;

变量的本质:一块连续的存储单元(内存,寄存器),变量不一定有地址.
变量有名字,用来表示存储单元的内容.
数据对象没有名字,是一种具有数据类型的连续存储单元(例:malloc申请的内存).
不同类型变量占据内存空间不同
计算机中任何有符号数都是以补码形式进行存储和运算,为了简化硬件.
不同编译器类型的大小也有所不同.
宏定义INT_MAX和INT_MIN代表有符号整型的最大值和最小值,同样还有CHAR_MAX,SCHAR_MAX等,这些宏定义在 limits.h 文件中.

ASCII码:用7位二进制表示128个字符.
最高位是校验位(奇校验和偶校验).

• 0~31是控制字符或通信专用字符(不可显示).
• 32~126是可显字符,包括数字,字母,标点符号等.

字符型数据在内存以ASCII码形式储存.
转义字符:
制表符 \t
回车符 \r
换行符 \n
每个变量占1个字节
允许对字符变量赋整数值,低八位赋值给字符变量,高八位截断.
字符和整数之间可以直接进行数值运算.
与浮点型进行运算时会自行转换 char >> int >> float

浮点数:可近似表示任意实数.
浮点型:float. double. long double,
float 占4字节
double占8字节
long double 占12字节
浮点数全是有符号数,最高位代表符号位
在内存的分布为 [符号位] [移码] [尾码(移位后剩余的小数)]
例:100.125(十进制)----1100100.001(二进制)
阶码为正数的二进制位数减一 ----1100100(7位-1) 最终阶码为6
阶码表示小数点向前移动多少位后使整数位为1.
移码 = 阶码 + 127 = 6 + 127 = 133(十进制) = 10000101(二进制).
最终内存分布为
[符号位][0]
[移码][10000101]
[尾码]100100001
最终100.125在内存中表示为0 1000101 100100001 = 0X42C84000(十六进制)

int main() {
	union{
		float f;
		int i; 
	}t;
	t.f = 100.125;
	printf("%x\n",t.i);
}

特别注意:不能直接比较浮点数是否相等.

int main() {
	float a = 0.1;
	float b = 0.1;
	if(a == b)//错误
	;
	#define EPSILON 1E-6
	if(abs(a-b)<EPSILON)//正确
	;
}

类型转换

C语言在进行数据运算时要求操作符两边数据类型相同.
编译器会自动进行类型转换,称为隐式转换.

隐式转换的发生条件

当算术或逻辑表达式中的操作数类型不同.
当赋值运算符两侧类型不匹配.
函数调用过程中实参和形参类型不匹配.
return语句中的表达式类型与函数返回类型不匹配.

算术运算转换规则

• 空间占用小的数据类型转换为空间大的数据类型
  浮点数:float-double-long double
  整数:char-int-unsigned-long-unsigned long-long long
• 转换规则
  在C99中可以将任何等级低于int或unsigned的类型转换到此类型,运算结束后再进行转换,比如char.
  如果两个数都没有浮点数，首先要将两个操作数整数提升
  如果两个数都是无符号型或者有符号型，将等级较低的类型转换为等级较高的.
  如果无符号数等级高于有符号数，将有符号数转换成无符号数类型.
  如果有符号数类型可以表示无符号数类型的所有值，将无符号数转换为有符号数类型.
  否则，将两个操作数都转换为与有符号数的类型相对应的无符号数.
• 转换等级
  long long、 unsigned long Iong、
  long 、unsigned longd、
  int、unsigned int、
  short、unsigned short、
  char、unsigned char
  _Bool

赋值运算转换规则

• 字符转换整型:高位补零.
• 整型转换字符型:截断.
• 整型转换浮点型:添加小数位.
• 浮点型转换整型:截断小数位.
• 字符型转换浮点型:(中间经过整型)
  -先提升为整型再添加小数位.
• 浮点型转换字符型:(中间经过整型)
  -先截断小数位,然后截断.

显示类型转换(强制类型转换)

• (类型名)表达式
• 转换的是指而不是变量的类型,值被转换成对应类型而变量的类型不变.

需要注意的地方

• 整型是指一系列数据的统称.
• char在运算过程中会做整型提升.

布尔类型_Bool(C99)

C99新增数据类型_Bool.
C99之前(包括C99)中没有bool、ture、false关键字.
但stdbool.h中通过宏定义让C语言能使用bool,true,false.使其兼容C++.

复数类型_Complex(C99)

• 基本概念:
  属于半个关键字,需要与其他关键字组合
  -float _Complex
  -double _Complex
  -long double _Complex

//复数的使用
#include <stdio.h>
#include <complex.h>//需要包含该文件才能使用复数
#include <stdlib.h>
int main() {
	double _Complex z1 = 1.5 + 7.2 * I;//定义一个复数.
	double _Complex z2 = 3.2 + 8.1 * I;//定义一个复数.
	double _Complex z3 = z1 + z2;
	printf("%lf + %lfi\n",creal(z3),cimag(z3));
}

运算符与表达式

• 运算符

C语言中定义的一些运算符号 + - * / & | >> …等.

• 表达式

表达式就是由运算符和操作数组成的一个符合C语法规则的式子序列.
单个常量或变量也是一个表达式.
根据运算符种类， 可分为不同种类表达式(算术表达式,关系表达式,逻辑表达式).
表达式运算后的结果为表达式的值.
值的类型为表达式.

• 语句

表达式+; =语句.
语句是对计算机的指令:声明语句、赋值、函数调用、结构化语句、空语句、复合语句…
语句可分为简单语句和复合语句，简单语句以;结束

• 运算符分类

单目运算符
双目运算符
三目运算符

C语言一共48中预算符

ANSI C:44种运算符.
C90:增加了一元+运算符;区分前缀后缀 ++/–.
C99:增加了复合字面运算符.

• 运算符的优先级

表达式中，优先级高的运算符先选择操作对象.
优先级用来确定运算符的操作对象，而不是用来确定运算次序的，后者是由编译器去决定的.
C语言优先级一共16级，16级最高，1级最低

记忆方法
[]、()、、->、++/–(后)、(类型名) {值列表}
++/-(前缀)
单目运算符、算术运算符、关系运算符、逻辑运算符、条件运算符、赋值运算符、逗号顺序求值

位逻辑运算符优先级高于逻辑运算符

• 运算符的结合性

结合性:
结合性就是一串操作符是从左往右依次执行还是从右往左依次执行
当表达式中运算符优先级相同，那么运算符就会根据结合性来挑选操作数。

左结合与右结合:
左边的运算符先挑运算对象，依次向右执行
右边的运算符先挑运算对象，依次向左执行
求值顺序和结合性无关，和编译器有关

右结合型的运算符:
单目运算符
赋值运算符
条件运算符

运算符需要注意的地方

• C99对新标准的/和%的修改

C99中 / 的结果总是向零取整.
C99中 % 的值的符号跟被除数相同.
逻辑运算符优先级:!>算术运算符>关系运算符> && >||> 赋值运算符

C语言的序列点(C99)

• 一个语句中不要对同一个变量做两次以上的修改,否则容易出现未定义的情况,不同编译器编译结果不同.

一些容易出错的优先级

• .的优先级高于*
• 的优先级高于++
• []的优先级高于*
• 函数()的优先级高于*
• ==和!=高于位操作
• ==和!=高于赋值运算符
• 算术运算符高于位移运算符
• 逗号运算符最低

printf/scanf家族

1.printf() 函数输出格式化的字符串.
2.sprintf() 函数把格式化的字符串写入变量中.
3.fprint() 函数把格式化的字符串写入指定的输出流(文件/流/数据库).
4 vprintf() ,vsprintf() ,vfprint(),这三个函数和上边三个一样，只是加v，参数放到数组里了。

1.scanf() 从输入终端读取数据.
2.fscanf() 从指定流或文件读入数据.
3.sscanf() 从参数所给的字符串中读取字符.
4.vsscanf() ,vscanf() ,vswscanf(),

• stdin 标准输入流
• stdout 标准输出流
• stderr 标准错误

结构化程序设计

语句与程序块

• 表达式语句
• 函数调用语句
• 流程控制语句
• 复合语句
• 空语句

三种控制流程

• 顺序结构
• 循环结构
• 选择结构
• 跳转结构

算法

• 算法 + 数据结构 + = 程序
• 流程图

结构化程序设计

• 自顶向下
• 逐步细化
• 模块化设计
• 结构化编码

函数

函数
类型标识符 函数名(类型1 形参1,类型2 形参2,…)

函数执行过程

传递参数—函数体运算—返回值

空函数

void fun(void) {

}

函数的原型,声明,定义

• 函数的原型
  函数的原型就是一个函数声明.
• 函数的声明
  描述参数类型和返回值.
  告诉编译器以作代码检测.
• 函数的定义
  实现函数的功能
  函数只能定义一次,但可以多次声明
  函数内不能定义函数

一些需要注意的地方
C89标准中若没有明确声明将默认为int型(返回类型,参数声明).
C99中不再支持隐含int.
C89标准中返回类型非void的函数可以使用不带返回值的return语句.
C99标准中返回类型非void的函数必须使用带返回值的return语句.

函数的参数

• 函数声明时可以不声明形参变量名,但变量类型必须一致.
• C99标准中参数的数量从31个增加到127个.

利用断言做参数检查

• 需要包含头文件
  若断言参数不为真则程序停止运行并在标准错误流打印信息.

int fun(int num) {
	assert(num != 0);
	int k = 100/num;
	return k;
}

函数的嵌套

• 除了main函数之外函数之间的关系是平等的.
• 在一个函数中不能定义另一个函数.
• 在一个函数中可以调用另一个函数.

递归函数

一个函数在函数体能调用该函数本身.
递归是嵌套调用的一种特殊的情况.

• 直接递归
• 间接递归

优点与缺点

• 帮助解决一些算法问题.
• 运行效率低,系统开销大.

递归函数需要注意的一些地方

• 防止递归层数太多而引起栈溢出.

内部函数与外部函数

函数本质上默认是外部的:extern
外部声明后可以被其他文件调用

内部函数:使用static修饰
只能被本文件的函数调用
可以与其他文件同名

内联函数

用inline修饰

int inine fun(void) {

}

优点

• 减少函数入栈和出栈的时间开销

缺点

• 占用内存空间

总结

• 以时间换空间
• 太长的内联函数编译器可能会当做一般函数处理
• 内联函数是通过编译器控制来实现,在使用的时候像宏一样展开

与一般函数和宏的区别

• 宏是在预处理阶段
• 内联函数是在编译阶段
• 宏没有返回值
• 内联函数可以有返回值

变量的作用域,属性,类型

作用域

变量在程序中的作用范围.

分类

• 代码块作用域
• 文件作用域
• 函数作用域
• 原型作用域

外部变量与局部变量

外部变量(局部变量)

• 函数外部定义的变量

局部变量

• 在函数或符合语句内部定义的变量
• 函数的形参也属于局部变量

外部变量和局部变量的作用域

• 变量的作用域与其定义的位置有直接关系

变量作用域的屏蔽

• 内层作用域屏蔽外层作用域

变量的链接属性

在程序的链接过程中可能出现各个代码段有相同名字的变量,这时候需要根据变量的链接属性来区分.

外部链接属性extern

• 外部变量,函数

内部链接属性internal

• 使用static修饰的变量,函数

无连接属性none

• 局部变量,auto类型变量

重新理解变量

变量的本质

• 一段连续内存空间的别名

声明变量的意义

• 建立变量符号表,符号表会和地址建立关联
• 编译器会根据变量的类型分配不同的内存
• 编译器会根据变量的类型决定如果进行存储和运算
• 编译器会根据变量的类型决定变量的取值地址

变量的名,变量的值,变量的左值和右值.

• 变量名就是标志服
• 变量的值就是内存中的数据
• 变量的左值和右值就是在该变量进行运算是处于等号的左边还是右边
• 处于等号右边时作为右值,此时用到的是变量空间中的内容
• 处于等号左边时作为左值,此时用到的是变量的地址

程序的存储分布

程序代码区(代码区)

• 硬盘或FLASH中的数据

静态存储区(数据区)

• 字符串等文字常量
• 全局变量
• 局部静态变量

动态存储区

• 堆
• 栈
• 局部变量
• 函数参数

变量的存储方式

自动变量:auto

• 在函数体内定义的变量默认为自动变量
• 作用域在函数体内或代码块内
• 动态存储:存储在栈中
• 编译器会自动分配和回收
• 在运行时分配和回收

静态变量:static

• 存储在及静态存储区
• 全局变量默认的存储方式是static
• 全局变量被static修饰后作用域发生改变,但存储方式不变
• static修饰局部变量后编译时初始化一次
• static修饰局部变量后改变了变量的存储方式
• static修饰局部变量后作用域不变

寄存器变量:register

• 没有地址
• 声明为寄存器类型的变量不一定存储在寄存器中
• 局部自动变量和形参也可以定义成寄存器变量
• 循环控制变量,循环体内返回使用的变量也可以定义成寄存器变量
• 优点:速度快,效率高

外部变量:extern

• 全局变量默认是外部变量
• 全局变量与外部变量
• • 全局变量:作用域的角度
• • 外部变量:存储方式的角度
• 其他文件使用外部变量,先声明后使用

关键字volatile

告诉编译器,该变量随时会发生变化,每次使用该变量直接到内存中去取而不是采用暂存在寄存器中的值.

变量同时使用const和volatile

• 状态寄存器
  被const和volatile同时修饰的变量相当于状态寄存器,只有硬件能对其进行修改.

库函数

• 标准C = C语言标准 + 标准库函数
  – 库函数源代码不可见,一般通过头文件引出
  – 库函数一般分为两种
  1.根据C标准实现的库函数
  2.编译器自己扩展的库函数

• 不同编译器对标准库实现有差异
  – 底层环境,软硬件方面存在差异
  – 不同架构的CPU的I/O实现上的差异

• 动态链接库与静态链接库
  – 静态链接库在程序编译链接的时候和用户代码链接在一起
  – 动态链接库在程序运行的时候有效
  – 使用静态链接库链接的代码体积较大

• C89标准中一共有15个头文件

#include //设定插入点
#include //字符处理
#include //定义错误码
#include //浮点数处理
#include //文件输入/输出
#include //参数化输入/输出
#include //数据流输入/输出
#include //定义各种数据类型最值常量
#include //定义本地化函数
#include //定义数学函数
#include //定义输入/输出函数
#include //定义杂项函数及内存分配函数
#include //字符串处理
#include //基于数组的输入/输出
#include //定义关于时间的函数

• C99标准中一共有24个头文件

新增

• complex.h
• fenv.h
• inttypes.h
• iso646.h
• stdbool.h
• stdint.h
• tgmath.h
• wchar.h
• wctype.h

数组

• 一组相同类型的数据组成的一组数据
• 数组使用下标[]或指针引用,下标从0开始
• C99新增赋初始值方式

/* 将a[0]赋初始100,a[9]赋初始900,其他均为0 */
int a[10] = {[0] = 100,[9] = 900};

数组名

• 使用数组可以为一组相同类型的变量命名同一个名称
• C语言把数组名解释为指向该数组首元素的地址
• 数组名和指向首元素的指针等价
• 当引用数组时,编译器会把数组名的值作为一个指针常量
• 用sizeof引用数组名的时候sizeof会返回整个数组的长度
• 当使用&对数组名进行取值的时候代表的是整个数组

main(void) {
	int a[10];
	//若a的地址为0,则&a+1结果为40.
	//因为&a表示的是整个数组,此时应当做一个数组的元素,且该元素大小为40字节.
}

• 当取一个数组名的地址&的时候产生的是一个指向数组的指针,而不是指向某个指针常量值的指针
• 数组名不能作为左值,数组名是一个指针常量,不能被修改
• 数组名作为右值时代表的是首元素的地址
• 编译器并没有为数组名分配一个内存空间来储存这个地址

若定义数组 int a[10];

• 则数组名代表的是首元素a[0]的地址&a[0],而不是数组的首地址&a
• 数组名a+1表示下一个数组元素的首地址&a[0]+1
• &a+1指向下一个数组的首地址
• 数组的索引从0开始
• C语言不对数组越界做检查
• 不指定数组长度时,根据初始化列表中元素的个数来决定
• C语言只支持一维数组(多维数组当作元素为数组的数组)
• 二维数组在内存中是连续的

字符数组与字符串

• 字符串比字符数组多一个结束符’\0’
• 字符串长度等于字符数+1

字符串处理函数

• 字符串输入gets
• 字符串输出puts
• 字符串长度strlen
• 字符串连接strcat
• 字符串指定长度连接strncat
• 字符串复制strcpy
• 字符串指定长度复制strncpy
• 字符串比较strcmp

需要注意的地方
strlen返回字符串长度(字符长度,不包括’\0’)

数组作为函数的参数

• 数组元素作为函数的参数

直接引用传入

• 数组名作为函数的参数

传递的是一个地址,或者说是常量指针

//注意:传入的是数组的地址,修改数组会影响实参.
//int fun(int a[])//不需要加具体长度也可以,因为传入的是一个指针.
int fun(int a[10]) {
	for(int i=0;i<10;i++) {
		a[i] = i;
	}
}
//用const修饰数组,防止数组被修改
int fun(const int a[]) {

}

• 二维数组作为函数的参数

//int fun)(int a[][10])
int fun(int a[2][10]) {
	
}

• 使用static修饰数组参数

//用static修饰表示告诉编译器该数组元素至少为5,此时传进来的不止是地址,还会把元素从传入
//节省程序从内存中读取元素的时间,用于提高程序的效率
//C99标准
int fun(int a[static 5]) {
	
}

变长数组

C99标准中数组定义时数组大小可以是一个变量

• 一维变长数组作为函数的参数

//一维变长数组作为函数的参数
//变长数组作为函数的参数时,数组长度变量必须声明在变长数组之前,即int n要在int a[n]之前
int fun(int n, int a[n]) {
	
}

• 二维变长数组作为函数的参数

//int fun(int rows, int cols, int a[][cols])
//int fun(int rows, int cols, int a[][*])//C99标准可以这样使用,但GCC没有实现该功能
int fun(int rows, int cols, int a[rows][cols]) {

}

• 变长数组是动态存储,在程序运行时分配内存
• 在函数体或代码块内声明
• 不能使用static或extrn进行修饰
• 作用域从声明处到代码块结束
  –下次再执行相同的代码块时会重新创建一个新的数组

指针

• 指针就是地址
• C语言中,内存单元地址称为指针
• 存放指针的变量叫指针变量
• 指针也有类型void,int,char,float…

指针的重要性

• 提供函数修改实参的方法
• 模拟引用调用
• 支持动态内存分配
• 支持动态分配的数组
• 支持动态数据结构:二叉树,链表等
• 指针常用于数组操作,遍历数组,而且效率比数组下标快
• 指针变量的大小由编译器决定,而不是由系统(32位,64位)决定
• 指针变量要先初始化,然后再引用

指向数组的指针

• 指针与数组的关系
  – 数组名可以看做是一个常量指针
  – 数组作为参数时,会退化为一个指针
• 指针与数组的区别
  – 数组是一种数据结构,而指针是一种整型变量
  – 指针保存数据地址,数组保存数据
  – 指针通过*间接访问,数组通过下标直接访问
• 数组名与指针
  – 数组名的内涵在于其指代实体是一种数据结构:sizeof/&
  – 数组名的外延在于其可以转换为指向其实体的指针,而且是一个指针常量
  – 指向数组的指针是一个整型变量,其存放的是这个数组的地址,而数组名没有单独的空间存放

数组指针作为函数的参数

• 数组名作为函数的参数
  – 会退化成一个常量指针
• 数组指针作为函数的参数

int a[10];
int *p = a;//指向数组首元素
int (*p2)[10] = a;//指向长度为10的数组,指向整个数组a,加括号是因为方括号的优先级高于*
int [10](*p2) 和 int (*p2)[10]相同
可以 int (*p2)[10] = a;也可以 int (*p2)[10] = &a;但后者因为类型不同会出现警告

指向二维数组的指针

• 二维数组的元素相当于指向数组的指针

#include <stdio.h>

int main(int argc, char *argv[])
{
	int a[2][3] = {{1,2,3},{4,5,6}};
	int (*p1)[3] = a;//指向二维数组的指针
	int (*p2)[3] = a[0];
	printf("p1 = %x\n",p1);
	printf("p2 = %x\n",p2);
	printf("p1[0] = %x\n",p1[0]);
	printf("p2[0] = %x\n",p2[0]);
	printf("p1+1 = %x\n",p1+1);
	printf("p2+1 = %x\n",p2+1);
	printf("p1[0][0] = %x\n",p1[0][0]);
	printf("p2[0][0] = %x\n",p2[0][0]);
	printf("(*p1)[0] = %x\n",(*p1)[0]);
	printf("(*p2)[0] = %x\n",(*p2)[0]);
	printf("(*p1+1)[0] = %x\n",(*p1+1)[0]);
	printf("(*p2+1)[0] = %x\n",(*p2+1)[0]);
	return 0;
}

运行结果

二维数组作为函数参数

int a[2][3];
//int fun(int rows, int a[2][3])
//int fun(int rows, int a[][3])
int fun(int rows, int (*p)[3]) 
{

}

指针数组

• 指针数组的定义

//每个元素都是字符串指针
//定义一个数组,该数组的每个元素都是一个指向char *类型的指针
//sizeof(p)的结果为20
//*(p+1) == p[1]
char *p[5] = {
"123",
"hello",
"world",
"12345",
"111111111111"
};

指针数组作为函数的参数

void fun(int len, char *p[]) {
	for(int i = 0; i < len; i++)
		printf("%s\n",p[i]);
}

指针数组和数组指针的区别

• 一个是数组,一个是指针整型变量
• 定义

int *a[10];//指针数组
int (*a)[10];//数组指针

指向函数的指针

• 函数指针无论取多少次*都是指向同一个地址
• 函数指针的定义

//定义一个函数
int fun(void) {}
返回类型 (*函数名)(形参) {
}
int (*funp)(void) {

}
//两种赋值方式结果一样
funp = fun;
funp = &fun;
//无论取多少次地址都是一样的结果
funp();
(*funp)();
(**funp)();

#include <stdio.h>
int fun(void) {
	printf("fun\n");
} 
int main(int argc, char *argv[])
{
	int (*funp)(void) = fun;
	fun();
	funp();
	(*funp)();
	(**funp)();
	(******funp)();
	(*fun)(); 
	(***fun)(); 
	printf("fun = %x\n",fun);
	printf("&fun = %x\n",&fun);
	printf("funp = %x\n",funp);
	printf("*funp = %x\n",*funp);
	printf("**funp = %x\n",**funp);
	printf("*****funp = %x\n",*****funp);
	unsigned int *p = (unsigned int *)fun;
	printf("p = %x\n",p);
	printf("*p = %x\n",*p);
	return 0;
}

运行结果

函数指针作为函数的参数

void fun(int (*funp)(int a, int b)) {

}

const关键字修饰指针

• 指向常量的指针

int a = 0;
//const修饰了*p,此时*p为一个常量无法被修改
//指向常量的指针
const int *p = &a;
int const *p = &a;//与上面相同
//可以对指针p进行修改,但不能对p所指向的常量进行修改

#include <stdio.h>

int main(int argc, char *argv[])
{
	int a = 10;
	int b = 10;
	const int *p = &a;
	int const *t = &a;
	a = 100; 
	printf("a = %d\n",a);
	printf("*p = %d\n",*p);
	printf("*t = %d\n",*t);
	/*
	因为*p和*t被const所修饰,所以*p和*t所指向一个常量类型(const int)的地址,
	而常量不能被修改,所以以下代码无法被编译通过.
	*p = 20;
	*t = 20;
	p = &b;
	t = &b;
	*p = 20;
	*t = 20;
	printf("b = %d\n",b);
	printf("*p = %d\n",*p);
	printf("*t = %d\n",*t);
	*/
	const const const const int const const const *k; 
	return 0;
}

• 常指针

int a = 10; 
int b = 20;
int * const p = &a;
*p = 100;
/*
因为p被const所修饰,所以p为一个常指针,该指针无法被修改,
只能指向定义时初始化的地址.,所以以下代码无法被编译通过. 
但是可以对指向的地址的内容进行修改.
p = &b;
*/

• 指向常量的常指针

int a = 10; 
int const * const p = &a;
/*
无法对指针p进行修改操作,也无法对所指向的内容进行修改.
但依然可以读取. 
*/ 
printf("p = %x\t*p = %d\n",p,*p); 

• 常量数组

int const arr[10];
/*
存放的元素都为常量,无法赋值,相当于指向常数的指针
arr[0] = 10;
*/

指针数组作为mian函数参数

• 入口函数mian的两种定义方式

int main(void) {
}
//int main(char *argc, char *argv[])
int main(char *argc, char **argv) {
}

__restrict__关键字修饰指针(C99)

• C99标准新增关键:修饰限定指针
• 规定其所修饰的指针是访问指针指向的数据的对象的唯一方式
  – 想要修改指针所指向的内存单元的内容,只能通过该指针进行修改
  – 其他指向这块内存的指针都是未定义的
• 使用restrict修饰指针的好处
  – 帮助编译器更好的优化代码

int a[10];
int * __restrict__p = (int*)malloc(10);
int *q = a;
for(int i = 0; i < 10; i++) {
	a[i] += 10;
	q[i] -= 10;
	p[i] += 5;
	a[i] *= 10;
	p[i] += 10;//编译器会优化成p[i] += 15;
}

– 提醒用户要使用满足restrict要求的参数

结构体

• 结构体是一种构造数据类型,自定义数据类型
• 定义
  – 先定义结构体类型,再定义结构体变量
  – 结构体定义不分配内存,变量才分配内存

结构体的储存

• 内存对齐
  – 字,双字,四字,在内存中没有强制必须对齐
  – 访问未对齐的数据变量需要两次总线周期
  – 编译器默认将结构体中的成员数据内存对齐
• 结构体的储存
  –结构体只能保证成员变量在内存中的存放顺序,但不能保证所占用内存大小
• 减少结构体存储空间的浪费
  – 重组数据成员
  – 边界要求最严格的先出现

格式一

struct tagPhone  
{  
     char   A;  
     int    B;  
     short  C;  
}Phone;

格式二

struct tagPhone  
{  
     char   A;  
     short  C;  
     int    B;  
}Phone2;

格式三

struct tagPhone3  
{  
     char   A;  
     char   B[2];  
     char   C[4];  
}Phone3;

• 位域

//结构体大小为char的大小,结构体成员分别占cahr的一定位宽
//下列a占内存的第1位(最低位),b占用2-3位,c占用第4位(最高位)
//若k.c = 1;则k的内存中的值为8,若k.a = 1;则k的内存中的值为1.
struct data {
	char a:1;
	char b:2;
	char c:1;
}k;

#include 
union {
	struct data_strcut {
		char a:1;
		char b:2;
		char c:1;	
	}k;	
	char data;
}test;

int main(int argc, char *argv[])
{
	printf("test size = %d\n",sizeof(test));
	test.data = 0;
	printf("test.data = %d\n",test.data);
	test.k.c = 1;
	printf("test.data = %d\n",test.data);
	return 0;
}

运行结果

共用体

• 共用体不能作为函数参数和返回值
• 共用体变量的值是最后一次存放的成员的值
• 共用体变量的地址和各成员地址相同
• 共用体可以和结构体相互嵌套

//这样嵌套定义可以使代码更加紧凑,比定义多个结构体更节省空间.
struct student {
	int name;
	int grade;
}
struct teacher {
	int name;
	int NO;
}
union union_data {
	struct student stu;
	struct teacher teh;
}
struct person {
	int age;
	int sex;
	union union_data u;
}

//这样嵌套使用可以模拟一个寄存器,可以进行字节寻址,也可以位寻址
union lcd_reg {
	struct lcd_control {
		int lcd_clr:2;
		int lcd_on:1;
		int lcd_cor:5;
	}lcd_bit;
	int lcd_data;
}reg;
reg.lcd_data = 0;//此处对整个寄存器清零
reg.lcd_bit.lcd_on = 1;//此处对寄存器的某一位置位

枚举

• 枚举的定义

//枚举中saturday类型中saturday的值默认为0,后面的成员依次递增
//若(saturday = 2,)时,saturday 的初始值为2,后面的成员也依次递增
//若(wednesday = 10,)时,wednesday 的初始值为10,后面的成员依次递增

enum day
{
    saturday,//(saturday = 2,)
    sunday,
    monday,
    tuesday,
    wednesday,//(wednesday = 10,)
    thursday,
    friday
} workday;
int a = 1;
enum day weekend;
weekend = friday;
weekend = (enum day)a;  //类型转换
//weekend = a; //错误

• 枚举是常量,不能作为左值被重新赋值
• 枚举不能是字符型或者字符串,使用时不能加单引号或双引号
• 枚举从0开始自动赋值
• 枚举变量的取值范围要在枚举类型定义的范围内

typedef

• 为基本数据类型定义新的类型名

//为结构体定义新的别名
typedef struct {
}student;
student a;
//为数组定义新的别名
typedef int arr_10[10];//等价 typedef int [10] arr_10;
arr_10 a;
sizeof(a);//结果为10*4 = 40
//为指针定义别名
typedef char * charp;
charp a = "hello world";
puts(a);
//typedef int (*myfun)(int a, int b);//等价 typedef int (*)(int a, int b) myfun;
int new_fun(int a, int b);
myfun p;
p = new_fun;

• 为构造数据类型定义简洁的类型名
• 为数据定义简洁的名称
• 为指针,函数指针定义一个新的名称
• typedef也有作用域
• typedef与#define的不同之处
  – typedef由编译器进行处理,宏由预处理执行

结构体成员为柔性数组(C99)

• 零长度数组不占用结构体空间
• 使用时数组将作为结构体的成员
• 数组使用前需要手动动态分配内存
• GCC是通过非标准扩展零长度数组来实现的
• 在GCC以外的编译器编译不一定能通过
• 定义零长度数组的意义
  – 在不确定数组大小的时候可以使用,节省内存
  – 可以用指针来代替,不过指针变量会占用一些空间

复合字面量(C99)

• 字面量:固定数值的表示
  – 基本数据类型字面量:100,12.34,“hello”
• 复合字面量
  – 构造数据类型:数组字面量,结构体字面量
• 优点
  – 使得函数构造数据类型参数传递可以不用在定义一个变量,直接使用复合字面量,省去赋值操作,使得参数传递更加简洁.

struct k{
	int a;
	int b;
};
int fun(struct num) {
	int sum;
	sum = num.a + num.b;
	return sum;
}
//传参
//类似java匿名内部类
fun((struct k){2,3});

void fun(int len, int a[10]) {

}
//传参
fun(10, (int [10]){0,1,2,3,4,5,6,7,8,9});

宏

• 预处理过程
  – 处理程序中以#号开头的命令
  – 执行#include命令,将使用该文件包含的头文件内容替换该指令
  – 执行#define命令,将程序中使用#define定义的宏替换成具体的数字
  – 预处理过后生成的文件还是C文件

常见的预处理命令

• 文件包含

#include

• 宏定义

#define
#undef

• 预定义的宏
  LINE
  FILE
  …

• 条件编译

#if
#endif
#elif
#else
#ifdef
#ifndef

• 其他命令

重置行号和文件名#line
产生错误信息#error
修改编译设置#pragma

宏定义

• 用一些标识符作为宏名来代替一些符号或常量的命令

• 在预处理阶段,预处理器会将程序中所有出现的宏名用宏定义中的字符串替换,这个过程称为宏替换或宏展开

• 宏定义格式

#define 宏名 字符串

带参数的宏定义

• 形式参数和实际参数
  – 在宏定义总的参数称为形式参数
  –在宏调用中的参数称为实际参数
  – 展开时，不仅要宏展开，还要用实参替换形参
• 定义格式
  – #define宏名(形参表)字符串
  – #和##操作符的使用

#define SUM(A,B)  printf("A+B = %d\n",A+B)

#define SUM2(A,B) printf(""#A"+"#B" = %d\n",A+B)

SUM(A,B);
->printf("A+B = %d\n",2+3)
SUM2(A,B);
->printf("""2""+""3"" = %d\n",2+3)

#define INT(n) a##n
int INT(1);//int a1;

#define INT(n) a##n
#undef INT
int INT(1);//出错无法通过

– #undef的使用

• 需要注意的地方
  – 当字符串为较复杂的表达式时记得加括号，防止因优先级而带来运算错误

使用宏需要注意的地方

• 一般使用大写字母来表示宏名，可以放在头文件中，宏定义也可以嵌套
• 使用宏定义时不要吝啬加括号，除非你考虑到了所有可能出现错误的情况
• 使用圆括号括住每个参数，保证每个参数在定义表达式中能正确分组
• 宏定义的作用域:定义开始到文件结尾或#undef处
• 宏定义要单独点一个逻辑行，若定义字符串太长可以使用 \ 换行续接

一些预定义的宏名

• DATA:当前源程序的创建日期
• FILE:当前源程序的文件名称(包含盘符和路径)
• LINE:当前被编译代码的行号
• STDC:返回编译器是否为标准C,是的话返回1,否则就不是标准C
• TIME:当前源程序的创建时间
• 注意:__func__不是宏,是预定义标识符

C99新增的内部宏

• STDC_HOSTED 若操作系统存在，则为1
• STDC_VERSION 199991L或更高。 代表C的版本
• STDC_IEC_599 若支持IEC 60559浮点运算，则为1
• STDCIEC_599_COMPLEX 复数运算，则为1
• __STDC_ISO_10646__由编译程序支持,用于说明ISO/IEC 10646标准的年和月格式:yyymmmL

其他预处理命令

• #line

重置行号和文件

1.#line 1000 "hello"
2.printf("行号 = %d\n",__LINE__);
3.printf("文件名 = %s\n",__FILE__);

结果
行号 = 1000
文件名 = hello

• #erroe
• 产生错误编译信息

#define PI 3.13
#if PI 

#else
	#error "NO define PI!\n"
#endif

• #pragma

//编译的时候显示的信息
#pragma message("这是自己添加的编译信息")

#pragma warning( warning-specifier : warning-number-list [; warning-specifier : warning-number-list…]
#pragma warning( push[ ,n ] )
#pragma warning( pop )
主要用到的警告表示有如下几个:
once:只显示一次(警告/错误等)消息
default:重置编译器的警告行为到默认状态
1,2,3,4:四个警告级别
disable:禁止指定的警告信息
error:将指定的警告信息作为错误报告

参考:https://blog.csdn.net/gggg_ggg/article/details/42006019

• pragma pack(4)

设置对齐模数

• 对齐模数
  – 跟处理器相关，强制内存对齐
  – 可以简化处理器和内存之间传输系统的设计
  – 可以提升读取数据的速度
• 结构体内成员按各自对齐模数对齐
• 结构体按结构体模数对齐
• 对齐模数大小的确定
  – 结构体成员对齐模数是#pragma指定值(或默认值)
  和该成员所占空间长度的较小值
  – 结构体对齐模数是#pragma指定值(或默认值)和结
  构体内最大的成员数据类型长度的较小值

_Pragma (“pack(4)”) (C99)

_Pragma 是一个操作符

_Pragma ("pack(4)")  等价于 pragma pack(4)

动态内存

• 静态内存分配
• 堆式存储分配
• 栈式存储分配

堆与栈的区别

• 内存分配和回收方式不同
  – 栈由操作系统自动分配和释放，速度快
  – 堆一般由程序员自己分配和释放，一般速度比较慢，而且容易产生碎片。
  若程序员不释放，程序结束时可能有0S回收
• 存放的内容不同
  – 栈一般存放函数的参数、局部变量
  – 堆的存放内容没有限制，由程序员决定
• 大小限制不同
  – 栈是由高地址向低地址扩展的一片连续内存区域， 栈顶的地址和栈的容
  量是系统预先定义好的
  – 堆是由低地址像高地址扩展，区域可以不连续，空间大，使用比较灵活，一般由内存管理来管理这片区域
• 数据结构不同
  – 栈是一种先进后出的数据结构
  – 堆的分配方式类似于链表，整个内存结构可以看做是一 颗树

动态内存申请和释放

• 内存分配函数malloc
• 内存分配函数calloc
• 调整已分配内存函数
• 内存释放函数

文件

流

• 输入输出I/O与流
• 流与缓冲区
• 标准输入输出
  – 标准输入流(设备): stdin:与键盘相连
  – 标准输出流(设备): stdout: 与显示器相连
  – 标准错误流(设备): stderr: 与显示器设备相连

什么是文件

• 文件是一组相关数据的有序集合
• 数据集的名称叫做文件名
• 文件一般存储在磁盘等外部介质上，使用时读取到内存
• 文件的分类
  – 用户角度:普通文件和设备文件
  – 编码方式: 文本文件和二进制文件
• 文件缓冲区

文件的打开和关闭

• 常见的文件打开方式
  – 只读: r(以r打开的文件必须已经存在)
  – 只写: w(以w打开的文件不存在时会自动创建)
  – 读和写方式:+
  – 追加: a(写入的时候会从文件末尾开始,不会覆盖原来的数据)
  – 文本文件:t(默认打开方式，可省略不写)
  – 二进制文件:b
• 文件路径
  – 默认为当前目录的文件
  – 字符串中的’‘之前需要再加一个’’

FILE *fp;
fp = fopen("test.c","wt");
fclose(fp);

文件的读写

• 字符读写函数: fgetc()/fputc()
• 字符串读写函数: fgets()/fputs()
• 数据块读写函数: fread()/fwrite()
• 格式化读写函数: fscanf()/fprintf()
• EOF是一个宏,表示文件结束