C语言笔记 03_常量&存储类

常量

常量是固定值，在程序执行期间不会改变。这些固定的值，又叫作字面量。

常量能够是任何的基本数据类型，好比整数常量、浮点常量、字符常量，或字符串字面值，也有枚举常量。

整数常量

整数常量能够是十进制、八进制或十六进制的常量。前缀指定基数：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'）[Unicode编码]。

在 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 预处理器定义常量的形式：

#include <stdio.h>
 
#define LENGTH 10   
#define WIDTH  5
#define NEWLINE '\n'
 
int main()
{
 
   int area;  
  
   area = LENGTH * WIDTH;
   printf("value of area : %d", area);
   printf("%c", NEWLINE);
 
   return 0;
}

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

value of area : 50

const 关键字

您可使用 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("value of area : %d", area);
   printf("%c", NEWLINE);
 
   return 0;
}

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

value of area : 50

咱们习惯性把常量的名字设置全大写。

存储类

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

• auto
• register
• static
• extern

auto 存储类

auto 存储类是全部局部变量，默认的存储类。

{
   int mount;
   auto int month;
}

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

register 存储类

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

{
   register int  miles;
}

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

static 存储类

static 存储类指示编译器在程序的生命周期内保持局部变量的存在，而不须要在每次它进入和离开做用域时进行建立和销毁。所以，使用 static 修饰局部变量能够在函数调用之间保持局部变量的值。

static 修饰符也能够应用于全局变量。当 static 修饰全局变量时，会使变量的做用域限制在声明它的文件内。

全局声明的一个 static 变量或方法能够被任何函数或方法调用，只要这些方法出如今跟 static 变量或方法同一个文件中。

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

#include <stdio.h>
 
/* 函数声明 */
// 函数的返回类型为void，函数的参数为void
void func1(void);

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

int main()
{
  while (count--) {
      func1();
  }
  return 0;
}
 
void func1(void)
{
/* 'thingy' 是 'func1' 的局部变量 - 只初始化一次
 * 每次调用函数 'func1' 'thingy' 值不会被重置。
 */                
  static int thingy=5;
  thingy++;
  printf(" thingy 为 %d ， count 为 %d\n", thingy, count);
}

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

thingy 为 6 ， count 为 9
thingy 为 7 ， count 为 8
thingy 为 8 ， count 为 7
thingy 为 9 ， count 为 6
thingy 为 10 ， count 为 5
thingy 为 11 ， count 为 4
thingy 为 12 ， count 为 3
thingy 为 13 ， count 为 2
thingy 为 14 ， count 为 1
thingy 为 15 ， count 为 0

extern 存储类

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

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

extern 修饰符一般用于当有两个或多个文件共享相同的全局变量或函数的时候，以下所示：

第一个文件：main.c

#include <stdio.h>
 
int count ;
extern void write_extern();
 
int main()
{
   count = 5;
   write_extern();
}

第二个文件：support.c

#include <stdio.h>
 
extern int count;
 
void write_extern(void)
{
   printf("count is %d\n", count);
}

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

$ gcc main.c support.c

这会产生 a.out 可执行程序，当程序被执行时，它会产生下列结果：

count is 5

---

参考自：https://www.runoob.com/cprogramming/c-tutorial.html