变量、类型和字面量#

一个例子#

变量、类型和字面量在C语言中处于重要的地位，不过在仔细理解这些概念之前，不妨先看一个例子：

/*var.c*/
#include <stdio.h>

int main(void)
{
    int var;
    var = 10;
    printf("%d\n", a);
    var = 20;
    printf("%d\n", a);
    return 0;
}

10
20

直观的理解这段代码，我们让var“等于”了两个数。第一次是10、第二次是20。 两次的printf()输出似乎也告诉我们这两个var有不一样的数值。这是怎么做到的呢？

我们在这个例子也看到了printf()的一个新用法：打印一个数值。 我们下面会看看到底怎么做。

变量（Variable）#

从数学上来讲，变量是一个“可以变化的量”。譬如 \(y = x + 3\) 中的 \(x\)。 从编程语言的角度来说确实如此。但是对于编程语言，我们还可以从另一个角度理解这个事情：

变量是内存（main memory）中的一块有名字的、固定大小的存储空间。 这块空间可以被程序写入数据，也可以被程序读取数据，这就是它为什么可以变化。

变量的声明（declaration）#

在使用变量之前，我们先要进行变量声明。

上述程序的第四行：

int var;

这一行声明了一个以int作为类型、var作为名称的变量。

这个变量的声明就是告诉编译器： “我们需要在内存中有一个int类型大小的空间，请你在编译时预留这样的一个空间。 并且我们把这个空间叫做var，请你在编译的时候将这个名字翻译成一个内存的地址（Adderss）。”

标识符（identifier）#

标识符标识了C语言中变量或和其他需要命名的实体，变量名就是一种标识符。

标识符是以大写字母、小写字母、数字和下划线_组成的字符串，且数字不能在开头。 标识符亦不能是关键词。例如，你不能取一个名叫return的变量。

标识符是我们随意取的，如果你把上面程序的var统统改成x，结果不会有什么不同。

顺带一提，函数名也是标识符。所以我们之前提到的命名约束对函数名也有效。

标识符的作用域（scope）#

一个标识符有它的作用域。作用域就相当于一个标识符的“作用范围”。 超出了这个作用范围，标识符就失效了。

对于一个变量来说，它的标识符所对应的作用域是： 从这个变量的声明开始，到这个声明所在的块结束。

在上面程序中我们的标识符var作用域是从声明：

int var;

开始，到main()的右括号结束。

我们现在“做点手脚”，把声明移到别的块中，看看会怎么样。

/*var.c*/
#include <stdio.h>

int main(void)
{
    {
        int var;
        var = 10;
    }
    printf("%d", var);
    return 0;
}

结果是编译器的一个报错。

这是因为var的声明在内部的一个块中，等到下边使用var时，已经不在变量标识符的作用域中了。 编译器找不到var。

例如下面的例子：

/*var.c*/

#include <stdio.h>

int main(void)
{
    int var;
    int var;
    var = 10;
    printf("%d", var);
    return 0;
}

会产生一个报错：

这样的代码虽然不会引发上面的错误（因为两个var声明的块不一样，不是同一个变量）：

/*var.c*/

#include <stdio.h>

int main(void)
{
    int var;
    var = 10;
    {
        int var;
        var = 20;
        printf("%d", var); /*print 20*/
    }
    return 0;
}

但是程序打印出来是20。因为：

类型（Type）#

类型是C语言中一个重要的概念。类型表示了一个值到底要如何存储、占多大空间， 以及运算的规则。

C语言的类型分为四大类：算术（Arithmetic）类型、枚举（Enumerate）类型、 派生（Derived）类型以及void（空类型）。

关于void，C语言中将他视作一个类型占位符。它的意思可以是“无”，又或者是“任意类型”。不过：

接下来我们详细说说算术类型：

算术（Arithmetic）类型#

算术类型是一类能够执行算术操作的类型。 它们分为两个大类：整数类型和浮点类型。

整数（Integer）类型#

顾名思义，整数类型的变量能够存储整数。一个整数类型除了决定它的位宽（占内存位数）以外， 还决定了它是否“有符号”。“有符号”表示这个类型能存储负数，“无符号”表示这个类型只能存储正数和0。 其中，整数类型中最基础的类型是int。它代表一个定长，有符号的整数。 在C标准中它至少有16位，不过现在通常64位的CPU能够支持的int位宽为32位。

int类型前面可以加以下的长度修饰符：short、long和long long。 其中short int比int更短，而long int和long long int比int更长。 这些类型中的int也可以不写，直接写成short、long和long long。

还有一种类型我们通常也归为整数类型：字符类型char。字符类型可以储存美国信息交换标准代码 （American Standard Code for Information Interchange, ASCII）表中的任意一个字符， 如a、A、1、+、(等。char通常比short int更短。占一个字节，一般是8位。

char、int、long和long long都可以前面加unsigned表示同样位宽的无符号整数。 特别的，signed char表示一个字节的有符号整数。

以下是整数类型的位宽：

（摘自zh.cppreference.com）

C语言规定了：所有整数类型位宽一定是字节的整数倍。且对于位宽，有： char \(\leq\) short \(\leq\) int \(\leq\) long \(\leq\) long long。 （极端情况下，允许一个机器的字节宽位64位，使得所有上述类型宽位都是64。）

C99标准中，还增加了_Bool类型表示布尔值。它亦可以看作一个整数类型。 它的长度足以存储0和1二值之一。其长度可能是一个字节，而非通常认为的1位。

浮点（Floating Point）类型#

浮点类型能保存浮点值的类型。

浮点值一共有三种类型，从小到大分别是float（单精度浮点值）、 double（双精度浮点值）和long double。

浮点值还支持-0.0（负零）、INFINITY（正无穷大）、 -INFINITY（负无穷大）和NaN（非数，Not a Number）这四个特殊值，它们有特殊的意义。

使用printf()函数输出数值的字符串表达#

我们在之前使用过printf()打印过字符串。接下来我们展示printf()如何打印数值。

首先我们说说如何给函数传入多个参数。如前面的例子里看到， 我们在括号中用逗号分隔的列表给函数传入多个参数。就像这样：

printf("%d", 12);

还有这样：

printf("%d %d", 12, 14);

跟数学里的多元函数 \(n = f(x, y, z)\) 差不多。

printf()中的第一的参数是一个字符串，我们叫他格式字符串（format string）。 我们在其中写入想要输出的内容，并使用%d代替我们想输出的int类型值。例如：

printf("The answer is: %d", 42);

会输出：

The answer is: 42

这里还有另外一个例子：

/*var.c*/
#include <stdio.h>

int main(void)
{
    int lhs, rhs, ans;
    lhs = 1;
    rhs = 1;
    ans = 2;
    printf("%d + %d = %d", lhs, rhs, ans);
    return 0;
}

1 + 1 = 2

格式字符串中，转换指定（Conversion specifications）是以%起头、以转换指定符结束的串。 它在printf()中并不直接输出，而是拿后面的参数去替代它输出。 转换指定中间则有一系列长度修饰符和其他修饰符。 转换指定符告诉printf()该怎么转换参数，而长度修饰符告诉它参数的长度， 其他修饰符则增添了一些其他信息。

转换指定符d指定的是一个有符号的十进制（decimal）整数输出， 下面列出了每个长度修饰符在d下对应的类型：

（摘自zh.cppreference.com）

譬如要以十进制输出一个long long类型的整数，那就使用%lld代表它。

转换指定符u指定的是一个无符号的十进制整数输出。 它的这五个长度修饰符对应的类型是上面这五种类型的无符号变体。 譬如要以十进制输出一个unsigned long long类型的整数，那就使用%llu代表它。

转换指定符f指定的是一个十进制小数输出， 默认情况下它是6位精度。

转换指定符e指定的是一个十进制科学计数法小数输出。

下面列出了每个长度修饰符在e或f下对应的类型：

（摘自zh.cppreference.com）

如果要输出一个char类型的字符，则转换指定是%c²。

赋值运算符（Assignment Operator）#

赋值运算符是我们要接触的第一个运算符。它将一个值赋与一个变量。

运算符连接起两个表达式，构成一个新的表达式。 前面提到过，要让一个表达式成为语句，需要加;。

变量在赋值时，会将被赋值表达的值写入这个变量，其原有的内容会被清除。 试一下开头那个例子就知道了。

下面的例子给出了两个变量之间的赋值，赋值号=：

#include <stdio.h>

int main(void)
{
    int foo, bar;
    foo = 10;
    bar = 20;
    printf("%d %d\n", foo, bar); /*10 20*/
    foo = bar;
    printf("%d %d\n", foo, bar); /*20 20*/
    return 0;
}  

#include <stdio.h>

int main(void)
{
    int foo, bar, temp;
    foo = 10;
    bar = 20;
    printf("%d %d\n", foo, bar); /*10 20*/
    temp = foo;
    foo = bar;
    bar = temp;
    printf("%d %d\n", foo, bar); /*20 10*/
    return 0;
}

字面量（Literal）#

字面量，就是值用字面直接写出来的一个量。比如说20之类的。相较而言， 变量的值并不是用字面写出来的。字面量没有办法更改，是一种常量（constant）。

整数字面量#

整数字面量表示一个整数常量。注意到：

• 八进制整数字面量由0开始。
• 十六进制整数字面量由0x/0X开始。
• 十进制整数字面量不由上面两种作为开始。

在不指定任何后缀的时候，编译器会从int开始，挑选一个位宽最小， 范围恰能涵盖到这个值的类型，作为这个字面量的类型。也就是说，编译器会依次尝试以下类型：

1. int
2. unsigned int
3. long
4. unsigned long
5. long long
6. unsigned long long³

如果指定了后缀u（或U），则编译器只会寻找其中的无符号类型。 如果指定了后缀l（或L），则编译器只会从long开始找。 如果指定了后缀ll（或LL），则编译器只会从long long开始找。

换言之，一个指定了llu后缀的整数字面量一定是unsigned long long类型的³。

以下是一些整数字面量的例子：

42
017
0xFF
123456u
147L
0x1234ABCDEFll

浮点数字面量#

浮点数字面量表示一个浮点数常量。注意到：

• 十进制浮点数字面量至少拥有小数点.或指数部分（E或e开始）中的一个。 （否则就是一个整数字面量）
  • 当只拥有小数点的时候，至少拥有整数部分或小数部分中的一个，如1.或.1。
• 十六进制浮点数字面量以0x/0X开始，必须有指数部分（P或p开始）。

十进制浮点数字面量的尾数会转换为一个十进制小数，指数部分表示了这个小数要乘以10的多少次幂。 合起来是一个科学计数法表示的小数。如1.5e3表示\(1.5 \times 10 ^ 3\)。指数是整数，可以为负。

十六进制浮点数字面量的尾数会转换为一个十六进制小数， 指数部分表示了这个小数要乘以2的多少次幂。 如0x1.8p1表示\((1 + \frac{8}{16}) \times 2 ^ 1 = 3\)。⁴

以下是浮点后缀所对应的类型，不同于整数字面量，你需要显示地指定类型：

以下是一些浮点数字面量的例子：

1.0
0.1
1.
.5
1e0
.2e-5f
0x1p0
0x1.fP5l

字符字面量#

不同于字符串字面量，字符字面量表示一个字符。 用''（一对单引号）包围。 某些字符用转义序列表示，比如'\n'表示换行符。

我们通常把字符字面量赋给一个char型⁵变量。 在一般情况下字符字面量与char型兼容。

初始化（Initalization）#

我们可以在变量声明时，就给它赋一个值，称之为初始化。

以下代码片段展现了一个初始化的例子：

int var = 0;
int foo = 1, bar = 2;

直观感受的话，这就是将声明和赋值表达式整合到一起。 上面的代码片段中我们声明了var、foo和bar三个int型变量。并初始化他们的值为0、1和2。

当然，初始化能比赋值做更多的事情。

“常”类型限定符#

常类型限定符const用来加在类型前面，表示该类型的常限定变量。如：

const int a = 1;

含有const限定类型的变量无法被赋值。但是它们是左值。当然， 它们可以被（也应该被）初始化。如果尝试对常限定变量赋值，会有编译器报错。如：

/*const.c*/
int main(void)
{
    const int i = 3;
    i = 4;
    return 0;
}

编译器会报错：

本章练习#

first: 17867114283024, second: 17592236376080

#include <stdio.h>
int main(void)
{
    long long first_var = 17592236376080ll;
    long long second_var = 17867114283024ll;
    long long temp = first_var;
    first_var = second_var;
    second_var = temp;
    printf("first: %lld, second: %lld", first_var, second_var);
    return 0;
}