前言

程序是对数据的操作。本章将对数据进行描述。描述其类型、特点和如何声明。
本章描述变量的三个属性：

• 作用域
• 链接属性
• 存储类型

一、基本数据类型

C语言中有四种基本数据类型：

• 整型
• 浮点型
• 指针
• 聚合类型（数组和结构）

1.1 整型

整型家族包括字符、短整型、整型和长整型，并且它们分为无符号和有符号两种。虽然听上去长整型所能表示的值要比短整型大，但这不一定正确。规定的整型规则是：
长整型至少应该和整型一样长，整型至少应该和短整型一样长
ANSI C提供了一个最小范围原则：

short至少16位，long int 至少32位。至于int的长度则由编译器决定。通常int是机器的自然位数。（当然不排除有些机器三种类型都是32位）
头文件limits.h说明了不同整型的特点。

尽管char类型是为了设计容纳字符类型，但是字符在本质上是最小的整型值。缺省的char要么是signed char 要么是unsigned char，这是取决于编译器的。这个事实意味着在不同的机器上char的取值范围可能不同。所以，只要当使用的char变量位于 signed char和 unsigned char交集的范围 才是可移植的。例如：ASCII就在该范围之内。

使用char交集 才是最佳选择，既不牺牲效率，也保证了可以执行

1.1.1 整型字面量

字面值常量
字面值(literal)是一种实体，制定了自身的值，且不允许发生改变。这区别于ANSI C的命名常量（const 修饰的变量）。
可以在字面值加上前缀或者后缀来改变缺省规则。如：

u10  //无符号整型10
u10L //无符号长整型10
0x16 //十六进制22
016 //八进制14
1
2
3
4

字符常量他们的类型总是int

'M' '\n' '??(' '\377'
1

标准也允许诸如‘abc’这类多字节字符常量，但是他们的实现在不同的环境中，可能不一样，因此不推荐使用。
最后，如果一个多字节字符常量前面有一个L，那么它是宽字符常量

L'X'   L'e^'
1

当运行时支持一种宽字符集时，就可以使用他们。

1.1.2 整型字面量枚举类型

枚举类型是指它的值为符号常量而不是字面值的类型。其定义形式如下：

//声明了一个枚举类型
emnu Jar_Type{CUP,PIN,QUART,HALF_CALLON};
//接下来声明枚举变量
enum Jar_Type milk_jug,gas_can;
1
2
3
4

当然，如果枚举变量只声明一次，可以将两句话合在一起。

emnu Jar_Type{CUP,PIN,QUART,HALF_CALLON}
milk_jug,gas_can;
1
2

每个符号常量都有自己的值。我么可以在声明枚举类型时，进行显示赋值

enum Fruit {apple=1,banana=10};
1

如果不显式声明符号常量，则符号常量默认从0开始，依次递增1。

由于字符常量是int 类型，可以直接做整数运算。但是如果这么做狠狠有可能失去其意义

1.2 浮点型

像3.14或者6.023*10^23 这样的数值，要么整型表示不精确，要么超出了其表示范围。
浮点数类型分为float ，double 和 long double。ANSI 规则 long double 至少和double意义长，double至少和float一样长。并且所有的浮点值要能够荣南从10^-37 ~ 10^37之间的任何值。
float.h头文件定义了最大值和最小值

1.3 指针类型

指针是C语言流行的重要原因。它能够实现list和tree的数据结构。虽然Pascal等语言也有指针，但是不允许在指针上执行算数和比较操作，也不允许以任何方式创建指向已经存在数据对象的指针。 由于C语言没有这方面的限制，因此用它编写的程序更为紧凑有效
指针就是一个地址，这个地址可以指向一个数据实体

指针常量指针常量的意义并不大。因为指针是存储变量的地址，通过这个地址来访问变量的值。由于在负责把变量赋值给内存中的位置，因此程序开发者不会实现知道。因此你可以通过取址运算获取变量地址，而不是将其声明为指针常量。

字符串常量
C语言不存在字符串类型，但是存在“字符串常量”。C语言中字符串的概念是：一串以NUL结尾的0个或者多个字符，字符串通常存储在字符数组中，这也是C语言没有显示的字符串类型的原因。
字符串常量的书写方式是：

"Hello"  "\aWarning!\a" "Line 1 \n :ome2"  ""
1

字符串常量可以是空，但是他依然以NUL结尾。 如果需要修改字符串，请把它放在字符数组里。因为ANSI中修改字符串常量的后果位置。
最后需要注意的是：在表达式用如果有字符串常量，可以将其赋值给一个字符指针。因此字符串常量的直接值是一个指针，而不是内容。因此不能赋值给字符数组。

二、基本声明

声明的格式
说明符(一个或者多个) 声明表达式

unsigned short int a;
// 声明简单数组
int a[20]
// 声明指针
int *p
1
2
3
4
5

2.1 初始化

//在变量声明后，使用赋值操作符=，进行初始化
int j = 10;
1
2

2.2 隐式声明

C语言中有几种声明，它的类型是可以省略的。

• 函数如果不显示的声明返回类型，它就默认返回int
• 就风格声明函数，如果省略了参数类型，就默认为int
• 如果编译器能够根据信息推断出该语句是一个声明，且没有类型，则默认其为int

b[10]; //ANSI C 编译错误
d; //ANSI C 编译错误
f(x){
return x +1;
}
1
2
3
4
5

使用隐士声明不是一个好主意。建议使用显式声明。

三、typedef

typedef 关键字是用来为类型定义一个别名的。这样做的好处就是 提高代码的可读性与可维护性。

//定义字符指针类型的别名为 ptr_to_char
typedef char *ptr_to_char;
//声明变量a和变量b的类型为字符指针
ptr_to_char a,b;
1
2
3
4

我们知道宏替换可以在编译器进行标签替换，也可以达到类型替换。那么，typedef 与宏替换是那么区分使用的呢？

#define prt_to_char char*
prt_to_char a,b;
1
2

如果使用宏定义，a的类型为字符指针，b的变量为字符类型。

四、常量

ANSI C提供一个中像声明变量一样来声明常量的方式。那就是使用const关键字。

//声明一个int类型的常量
const int AGE = 18;
//在函数声明中，使用const，保证函数内部不会修改入参
void readInfo(const char* name , const int age);
1
2
3
4

对于const修饰指针，其实它有两个部分可以修饰：指针部分和指针指向的数据实体部分。

//指针常量
int const *cpi;
//常量指针
const int* pci;
//指向常量的指针常量
const int const* cpci;
1
2
3
4
5
6

那么使用const 定义的常量和宏定义的常量 我们该如何区别使用呢？

#define MAX_ELEMENTS 50
int const MAX_ELEMENTS = 50;
1
2

在上述的情况下，选择#define的方式比较好。因此只要允许使用字面值常量的地方都可以使用前者，比如数据长度。const变量只能用于使用变量的地方。

五、作用域（scope）

• 块作用域
• 文件作用域
• 函数声明作用域
• 函数作用域

在C语言中，最最常见的就是前两种。
作用域是一个变量的有效范围。也就是 如果在某个范围内只要持有变量名，就能访问，那么该范围就是该变量的作用域。这样说明不同作用域可以使用相同的变量名。

//文件作用域
int a;
//函数b为文件作用域
int b(int c);
//函数d为文件作用域
//形参变量e在函数代码块能够访问，也具有代码块作用域
int d(int e){
//局部作用域
int f; 
//该函数声明具有局部作用域，因为其在代码块中声明，外部无法使用
int g(int h); 
{
//局部作用域
int i,g,h;
}
{
//局部作用域
int i;
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

位于一对花括号之间的所有语句被成为一个代码块。代码块开始位置声明的标识符具有代码块作用域。

注意不推荐在嵌套代码块中出现同名变量
在K&R C中，如果函数体内部声明了与形参同名的变量，它将会屏蔽函数的形参。没有人会可以屏蔽形参。因此在ANSI C中，定义了形参具有函数最外层的那个作用域。因此不能再在那个最外层作用域声明与形参同名的变量。

任何在代码块之外的声明的标识符都具有文件作用域。另外需要指出的是 使用#include引入头文件时，就好像它们是字节卸载文件中一样。它们的作用不局限于头文件尾部。

函数原型作用域：在声明函数形参时，参数名不能相同，因此它们有相同的作用域。
函数作用域：只适用于语句标签，也就是goto使用的标签。最好不要使用哦

六、链接属性

在将源码编译为可执行文件的过程中。会有链接阶段。链接是在源文件编译为目标文件之后，将这些目标文件整合为可执行文件的过程。这里就会面临如何处理不同目标文件中的同名变量 答案是链接属性。 链接属性告诉链接器该如何处理同名变量。
链接属性一共有三种：external ，internal 和 none.

在代码块之外声明的变量或者方法，默认的链接属性为external。而代码块内声明的变量默认连接属性为none.

//定义类型变量a
typedef char *a;
int b;
int c(int d){
int e;
int f(int g);
}
1
2
3
4
5
6
7

在缺省情况下，b c f 的链接属性为external。其余标识符默认链接属性为none。如果另一个文件也包括了标识符b的声明并调用了c函数，他们实际上访问的身世这个源文件的实体。
f链接属性之所以为external，因为他是个函数名，在这个源文件调用函数f，实际上将链接到其他源文件定义的函数，甚至这个函数定义会在某个库中。

关键字extern和static用来修改链接属性。

static int b;
static int i();
1
2

static只会将默认为external的链接属性修改为internal。
extern比较复杂。它修改变量，使得变量的访问属性变为external。这样一来，函数就可以访问在其他源文件中声明的外部变量了。

//第一次声明i为internal类型
staitc int i;
int func(){
int j;
extern int k;
//因此此处的i并不是第一次声明
extern int i; 
}
1
2
3
4
5
6
7
8

extern关键字作用于原文件中一个标识符的第一次声明时，它指定该标识符具有external属性。答案是如果不是第一次，则不会改变由第一次所声明的链接属性。

七、存储类型

变量的存储类型是指值存储变量值的内存类型。该内存类型分为三种：普通内存，运行时堆栈、寄存器。存储类型不同，其特性也不同。
变量的缺省存储类型，由它的声明位置决定的。
凡是在任何代码块之外声明的变量总是存储在静态内存中，也就是不属于堆栈的内存。这类变量称为静态变量，并且不能为这类变量指定其他存储类型。其声明周期：在整个程序运行期间使用存在。如果不为其显示赋值或者退出，其值始终不变。
在代码块内部声明的变量为自动变量，存储在堆栈中。随着代码块的技术，自动销毁。
可以将代码块的变量通过加上关键字static，使其变为静态的，该变量会在程序运行期间一直存在。注意函数的形参不能声明为static，因为实参总是在堆栈中传递给函数，用于递归。
最后是通过register声明的存储在寄存器中的变量。这只是开发者的一种建议存储方式，编译器未必会采用。
初始化
静态变量默认初始化为0，除非对其显示赋值。而自动变量，由于是其位置不固定，会有“脏数据”，需要实现初始化一下。

八、static关键字

static 关键针对链接属性和存储类型都有意义。当static修饰默认为external链接属性的声明时，会将其链接属性变为internal。但是这并不会影响其作用域和存储类型。
同样，当static关键字修饰自动变量时，会将其存储类型变为静态类型。但这不会改变其作用域。（自动变量的没有链接属性）

九、作用域、存储类型示例

接下来使用一个代码示例来练习一下

//external 变量
int a = 5;
//external 变量，此处的extern可以省去
extern int b;
//internal 变量
static int c;
//以上变量的作用域都是 文件作用域

//声明并定义external的函数d
int d(int e){
    //局部变量 f
    int f = 15;
    //可能是寄存器变量的 b
    register int b;
    //存储类型为静态 的变量g
    static int g = 20;
    //已经声明过的 链接属性为internal的a
    extern int a;
    {
        int e;
        int a;
        //链接属性为external的h
        extern int h;
    }
    
    {
        int x;
        int e;
    }
    return 0;
}

//声明一个链接属性为internal的函数
static int i(){
    return -1;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

十、总结

声明为external的链接属性的变量也成为全局变量，并且在所有源文件中都可以访问它。如果一个变量声明与代码内部，并且在前面添加了extern，则表示该函数使用的是全局变量，而非局部变量。

//file: a.c
int a = 100;
//file: b.c
int func(){
    int a = 10;
    {
       extern int a;
        printf("a = %d\n",a); //输出100
        return -1;
    }
}

1
2
3
4
5
6
7
8
9
10
11
12