[Daozy][C 语言入门课程]第3课 变量、常量、类型修饰符

椟夜学院–C 语言入门课程

官方网站：https://www.duyeyun.top/college

当前课程对应视频：https://www.duyeyun.top/college/detail?course_id=1&seq=3

C 变量

变量其实只不过是程序可操作的存储区的名称。C 中每个变量都有特定的类型，类型决定了变量存储的大小和布局，该范围内的值都可以存储在内存中，变量的名称可以由字母、数字和下划线字符组成。它必须以字母或下划线开头。大写字母和小写字母是不同的，因为 C 是大小写敏感的。基于前一章讲解的基本类型，有以下几种基本的变量类型：

char a = 'a';   // 整数类型
int b = 10;     // 整数类型
float c = 0.2; 
double d = 1.2;
void* e = 0;    // void 不能单独使用，只能作为指针使用
bool f = true;  // 整数类型

C 语言也允许定义各种其他类型的变量，比如枚举、指针、数组、结构、共用体等等，这将会在后续的章节中进行讲解，本章节我们先讲解基本变量类型。

C 中的变量定义

变量定义就是告诉编译器在何处创建变量的存储，以及如何创建变量的存储。变量定义指定一个数据类型，并包含了该类型的一个或多个变量的列表，如下所示：

type variable_list;

在这里，type 必须是一个有效的 C 数据类型，可以是 char、w_char、int、float、double、bool 或任何用户自定义的对象，variable_list 可以由一个或多个标识符名称组成，多个标识符之间用逗号分隔。下面列出几个有效的声明：

int    i, j, k;   // 一行声明多个相同类型变量
char   c, ch;
float  f, salary;
double d;

行 int i, j, k; 声明并定义了变量 i、j 和 k，这指示编译器创建类型为 int 的名为 i、j、k 的变量。

变量可以在声明的时候被初始化（指定一个初始值）。初始化器由一个等号，后跟一个常量表达式组成，如下所示：

type variable_name = value;

下面列举几个实例：

int d = 3, f = 5;    // d 和 f 的声明与初始化
int d = 3, f = 5;    // 定义并初始化 d 和 f
char x = 'x';        // 变量 x 的值为 'x'

C 中的变量声明

变量声明向编译器保证变量以指定的类型和名称存在，这样编译器在不需要知道变量完整细节的情况下也能继续进一步的编译。变量声明只在编译时有它的意义，在程序连接时编译器需要实际的变量声明。

变量的声明有两种情况：
1. 一种是需要建立存储空间的。例如：int a 在声明的时候就已经建立了存储空间。
2. 另一种是不需要建立存储空间的，通过使用extern关键字声明变量名而不定义它。 例如：extern int a 其中变量 a 可以在别的文件中定义的。

除非有extern关键字，否则都是变量的定义。

extern int i; //声明，不是定义
int i; //声明，也是定义

实例分析

尝试下面的实例，其中，变量在头部就已经被声明，但是定义与初始化在主函数内：

#include <stdio.h>

// 变量声明
extern int a;
extern int b;
extern int c;
extern float d;

int main () {
    // 变量定义
    int a;
    int b;
    int c;
    float d;

    // 初始化
    a = 1;
    b = 2;

    c = a + b;
    printf("c = %d\n", c);

    d = 33.3/b;
    printf("d = %f\n", d);

    return 0;
}

当上面的代码被编译和执行时，它会产生下列结果：

c = 3
d = 16.650000

C 中的左值（Lvalues）和右值（Rvalues）

C 中有两种类型的表达式：
1. 左值（lvalue）：指向内存位置的表达式被称为左值（lvalue）表达式。左值可以出现在赋值号的左边或右边。
2. 右值（rvalue）：术语右值（rvalue）指的是存储在内存中某些地址的数值。右值是不能对其进行赋值的表达式，也就是说，右值可以出现在赋值号的右边，但不能出现在赋值号的左边。

变量是左值，因此可以出现在赋值号的左边。数值型的字面值是右值，因此不能被赋值，不能出现在赋值号的左边。下面是一个有效的语句：

int g = 20;

但是下面这个就不是一个有效的语句，会生成编译时错误：

10 = 20;

C 常量

常量是固定值，在程序执行期间不会改变。这些固定的值，又叫做字面量。
常量可以是任何的基本数据类型，比如整数常量、浮点常量、字符常量，或字符串字面值，也有枚举常量。
常量就像是常规的变量，只不过常量的值在定义后不能进行修改。

整数常量

整数常量可以是十进制、八进制或十六进制的常量。前缀指定基数：0x 或 0X 表示十六进制，0 表示八进制，不带前缀则默认表示十进制。

整数常量也可以带一个后缀，后缀是 U 和 L 的组合，U 表示无符号整数（unsigned），L 表示长整数（long）。后缀可以是大写，也可以是小写，U 和 L 的顺序任意。

下面列举几个整数常量的实例：

212         /* 合法的 */
215u        /* 合法的 */
0xFeeL      /* 合法的 */
078         /* 非法的：8 不是八进制的数字 */
032UU       /* 非法的：不能重复后缀 */

以下是各种类型的整数常量的实例：

85         /* 十进制 */
0213       /* 八进制 */
0x4b       /* 十六进制 */
30         /* 整数 */
30u        /* 无符号整数 */
30l        /* 长整数 */
30ul       /* 无符号长整数 */

浮点常量

浮点常量由整数部分、小数点、小数部分和指数部分组成。您可以使用小数形式或者指数形式来表示浮点常量。
当使用小数形式表示时，必须包含整数部分、小数部分，或同时包含两者。当使用指数形式表示时， 必须包含小数点、指数，或同时包含两者。带符号的指数是用 e 或 E 引入的。
下面列举几个浮点常量的实例：

3.14159       /* 合法的 */
314159E-5L    /* 合法的 */
510E          /* 非法的：不完整的指数 */
210f          /* 非法的：没有小数或指数 */
.e55          /* 非法的：缺少整数或分数 */

字符常量

字符常量是括在单引号中，例如，’x’ 可以存储在 char 类型的简单变量中。

字符常量可以是一个普通的字符（例如 ‘x’）、一个转义序列（例如 ‘\t’），或一个通用的字符（例如 ‘\u02C0’）。

在 C 中，有一些特定的字符，当它们前面有反斜杠时，它们就具有特殊的含义，被用来表示如换行符（\n）或制表符（\t）等。下表列出了一些这样的转义序列码：

转义序列    含义
\\  \ 字符
\'  ' 字符
\"  " 字符
\?  ? 字符
\a  警报铃声
\b  退格键
\f  换页符
\n  换行符
\r  回车
\t  水平制表符
\v  垂直制表符
\ooo    一到三位的八进制数
\xhh . . .  一个或多个数字的十六进制数

下面的实例显示了一些转义序列字符：

#include <stdio.h>

int main() {
   printf("Hello\tWorld\n\n");
   return 0;
}

当上面的代码被编译和执行时，它会产生下列结果：

Hello   World

字符串常量

字符串字面值或常量是括在双引号 “” 中的。一个字符串包含类似于字符常量的字符：普通的字符、转义序列和通用的字符。您可以使用空格做分隔符，把一个很长的字符串常量进行分行。下面的实例显示了一些字符串常量。下面这三种形式所显示的字符串是相同的。

"hello, dear"

"hello, \

dear"

"hello, " "d" "ear"

定义常量

在 C 中，有两种简单的定义常量的方式：
1. 使用 #define 预处理器。
2. 使用 const 关键字。

下面是使用 #define 预处理器定义常量的形式：

#define identifier value

具体请看下面的实例：

#include <stdio.h>

#define LENGTH 10   
#define WIDTH  5
#define NEWLINE '\n'

int main() {
    int area = 0;

    area = LENGTH * WIDTH;
    printf("area = %d", area);
    printf("%c", NEWLINE);
    printf("area = %d", area);
    printf("%c", NEWLINE);

    return 0;
}

执行结果：

area = 50
area = 50

您可以使用 const 前缀声明指定类型的常量，如下所示：

const type variable = value;

具体请看下面的实例：

#include <stdio.h>

int main() {
   const int  LENGTH = 10;
   const int  WIDTH  = 5;
   const char NEWLINE = '\n';
   int area;  

   area = LENGTH * WIDTH;
   printf("area : %d", area);
   printf("%c", NEWLINE);

   return 0;
}

执行结果：

area = 50
area = 50

请注意，把常量定义为大写字母形式，是一个很好的编程实践。

类型修饰

定义 C 程序中变量/函数的范围（可见性）和生命周期。这些修饰符放置在它们所修饰的类型之前。下面列出 C 程序中可用的类型修饰符：

auto
register
static
extern

auto

所有局部变量默认的修饰符

{
   int mount;
   auto int month;
}

上面的实例定义了两个相同的变量，auto 只能用在函数内，即 auto 只能修饰局部变量。

register

用于定义存储在寄存器中而不是 RAM 中的局部变量。这意味着变量的最大尺寸等于寄存器的大小（通常是一个词），且不能对它应用一元的 ‘&’ 运算符（因为它没有内存位置）。

{
   register int miles;
}

寄存器只用于需要快速访问的变量，比如计数器。还应注意的是，定义 ‘register’ 并不意味着变量将被存储在寄存器中，它意味着变量可能存储在寄存器中，这取决于硬件和实现的限制。

static

指示编译器在程序的生命周期内保持局部变量的存在，而不需要在每次它进入和离开作用域时进行创建和销毁。因此，使用 static 修饰局部变量可以在函数调用之间保持局部变量的值。
static 修饰符也可以应用于全局变量。当 static 修饰全局变量时，会使变量的作用域限制在声明它的文件内。
static 是全局变量的默认存储类，以下两个变量 (count 和 road) 都有一个 static 存储类。

#include <stdio.h>

static int count;
int road;

int main() {
    printf("count = %d\n", count);
    printf("road = %d\n", road);

    return 0;
}

运行结果：

Count = 0
Road = 0

以下实例演示了 static 修饰全局变量和局部变量的应用：

#include <stdio.h>

// 函数声明
void test();

// 全局变量 - static 是默认的
static int count = 10;

int main() {
    while (count--) {
      test();
    }

    return 0;
}

void test() {
    /* 
     * 'thingy' 是 'func1' 的局部变量 - 只初始化一次
     * 每次调用函数 'func1' 'thingy' 值不会被重置。
     */                
    static int i = 5;

    i++;

    printf("i = %d, count = %d\n", i, count);
}

实例中 count 作为全局变量可以在函数内使用，thingy 使用 static 修饰后，不会再每次调用时重置。
可能您现在还无法理解这个实例，因为我已经使用了函数和全局变量，这两个概念目前为止还没进行讲解。即使您现在不能完全理解，也没有关系，后续的章节我们会详细讲解。当上面的代码被编译和执行时，它会产生下列结果：

i = 6, count = 9
i = 7, count = 8
i = 8, count = 7
i = 9, count = 6
i = 10, count = 5
i = 11, count = 4
i = 12, count = 3
i = 13, count = 2
i = 14, count = 1
i = 15, count = 0

extern

用于提供一个全局变量的引用，全局变量对所有的程序文件都是可见的。当您使用 ‘extern’ 时，对于无法初始化的变量，会把变量名指向一个之前定义过的存储位置。

当您有多个文件且定义了一个可以在其他文件中使用的全局变量或函数时，可以在其他文件中使用 extern 来得到已定义的变量或函数的引用。可以这么理解，extern 是用来在另一个文件中声明一个全局变量或函数。

extern 修饰符通常用于当有两个或多个文件共享相同的全局变量或函数的时候，如下所示：
第一个文件：test.c:

#include <stdio.h>

// static int count;
int count;

extern void print_count();

int main() {
   count = 5;

   print_count();

   return 0;
}

第二个文件：support.c:

#include <stdio.h>

extern int count;

void print_count() {
   printf("count = %d\n", count);
}

在这里，第二个文件中的 extern 关键字用于声明已经在第一个文件 main.c 中定义的 count。现在 ，编译这两个文件，如下所示：

$ gcc main.c support.c

$ ./a.out

执行结果：

count = 5

注意：当 int count; 前面加了static修饰符后，其不能被当前.c文件以外的.c文件引用，编译错误(不同版本的编译器提示可能不一样)：

/tmp/ccivtre6.o：在函数‘print_count’中：
test.c:(.text+0x6)：对‘count’未定义的引用
collect2: 错误：ld 返回 1

课后问题

1. 如果没有初始化的变量，默认值是多少？

有兴趣的朋友，请关注微信公众号，有机会获取平台代币：

进入社区贡献者微信群，有机会获取平台代币：