C语言编程节2

你好！ C 语言是一种通用的、面向过程式的计算机程序设计语言。

一、变量

变量其实只不过是程序可操作的存储区的名称。C 中每个变量都有特定的类型，类型决定了变量存储的大小和布局，该范围内的值都可以存储在内存中，运算符可应用于变量上。

变量的名称可以由字母、数字和下划线字符组成。它必须以字母或下划线开头。大写字母和小写字母是不同的，因为 C 是大小写敏感的。以下几种基本类型存储空间

类型	描述
char	通常是一个字节（八位）, 这是一个整数类型
int	整型，4 个字节，取值范围 -2147483648 到 2147483647
float	单精度浮点值。单精度是这样的格式，1位符号，8位指数，23位小数
double	双精度浮点值。双精度是1位符号，11位指数，52位小数
void	类型缺失

C 语言也允许定义各种其他类型的变量，比如枚举、指针、数组、结构、共用体等等

1、变量定义

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

type variable_list;

type 表示变量的数据类型，可以是整型、浮点型、字符型、指针等，也可以是用户自定义的对象。

variable_list 可以由一个或多个变量的名称组成，多个变量之间用逗号,分隔，变量由字母、数字和下划线组成，且以字母或下划线开头。

//定义整形变量
int nNum;
//定义浮点型
float fMoney;
//定义字符型变量
char grade;
//定义指针变量：
int *ptr;
//定义多个变量：
int    i, j, k;

2、变量的初始化

C 语言中，变量的初始化是在定义变量的同时为其赋予一个初始值。变量的初始化可以在定义时进行，也可以在后续的代码中进行。如下所示：

type variable_name = value;

//定义整形变量
int nNum = 1;             // 赋值为1
nNum = 20;                // 变量x初始化为20
//定义浮点型
float fMoney = 10.123;    // 赋值为10.123
//定义字符型变量
char grade = 'a';
//定义指针变量：
int *ptr = null;

变量没有显式初始化，那么它的默认值将取决于该变量的类型和其所在的作用域。对于全局变量和静态变量（在函数内部定义的静态变量和在函数外部定义的全局变量），它们的默认初始值为零。局部变量（在函数内部定义的非静态变量）不会自动初始化为默认值，它们的初始值是未定义的（包含垃圾值）。因此，在使用局部变量之前，应该显式地为其赋予一个初始值。

总结起来，C 语言中变量的默认值取决于其类型和作用域。全局变量和静态变量的默认值为 0，字符型变量的默认值为 \0，指针变量的默认值为 NULL，而局部变量没有默认值，其初始值是未定义的。

3、变量声明

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

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

例如：
tools.c文件代码

#include <stdio.h>
extern int x;
extern int y;
int add_function()
{
	return x + y;
}

main.c文件代码

#include <stdio.h>
int x=1;
int y=2;
int add_function();
int main()
{
    int result = 0;
    result = add_function();
    printf("result 为: %d\n",result);
    return 0;
}

输出结果：

result 为:3

二、常量

常量，按照字面意思讲就是不会改变的值，固定值，在程序执行期间不会改变。常量可以是任何的基本数据类型，比如整数常量、浮点常量、字符常量，或字符串字面值，也有枚举常量。常量的值在定义后不能进行修改。常量可以直接在代码中使用，也可以通过定义常量来使用。

1、整型常量

整型常量前缀：
八进制常量：前缀是0 表示八进制。
十进制常量：不带前缀，默认是十进制。
十六进制的常量：前缀是0x 或 0X 表示十六进制。

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

//十进制
int nNum1 = 10;
//八进制
int nNum2 = 012;
//十六进制
int nNum3 = 0xA;
unsigned int myUnsignedInt = 10U;

2、浮点常量

浮点常量由整数部分、小数点、小数部分和指数部分组成。可以使用小数形式或者指数形式来表示浮点常量。
当使用小数形式表示时，必须包含整数部分、小数部分，或同时包含两者。
当使用指数形式表示时， 必须包含小数点、指数，或同时包含两者。带符号的指数是用 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

字符常量的 ASCII 值可以通过强制类型转换转换为整数值。

char myChar = 'a';
int myAsciiValue = (int) myChar; // 将 myChar 转换为 ASCII 值 97

3、字符串常量

字符串字面值或常量是括在双引号 " " 中的。一个字符串包含类似于字符常量的字符：普通的字符、转义序列和通用的字符。您可以使用空格做分隔符，把一个很长的字符串常量进行分行。

//字符串：hello, world
"hello, world"
//字符串：hello," world " 
"hello,\" world \""

定义常量
使用 #define 预处理器： #define 可以在程序中定义一个常量，它在编译时会被替换为其对应的值。
使用 const 关键字：const 关键字用于声明一个只读变量，即该变量的值不能在程序运行时修改。

#define 预处理器
定义模式：#define 常量名 常量值

#define PI 3.14

const 关键字
定义模式：const 数据类型 常量名 = 常量值;

const int MAX_VALUE = 100;

4、#define 与 const 区别

#define 与 const 这两种方式都可以用来定义常量，选择哪种方式取决于具体的需求和编程习惯。通常情况下，建议使用 const 关键字来定义常量，因为它具有类型检查和作用域的优势，而 #define 仅进行简单的文本替换，可能会导致一些意外的问题。

#define 预处理指令和 const 关键字在定义常量时有一些区别：

替换机制：#define 是进行简单的文本替换，而 const 是声明一个具有类型的常量。#define 定义的常量在编译时会被直接替换为其对应的值，而 const 定义的常量在程序运行时会分配内存，并且具有类型信息。

类型检查：#define 不进行类型检查，因为它只是进行简单的文本替换。而 const 定义的常量具有类型信息，编译器可以对其进行类型检查。这可以帮助捕获一些潜在的类型错误。

作用域：#define 定义的常量没有作用域限制，它在定义之后的整个代码中都有效。而 const 定义的常量具有块级作用域，只在其定义所在的作用域内有效。

调试和符号表：使用 #define 定义的常量在符号表中不会有相应的条目，因为它只是进行文本替换。而使用 const 定义的常量会在符号表中有相应的条目，有助于调试和可读性。

三、存储类

1、auto 存储类

auto 存储类是所有局部变量默认的存储类。
定义在函数中的变量默认为 auto 存储类，这意味着它们在函数开始时被创建，在函数结束时被销毁。

{
   int mount;
   auto int month;
}

2、register 存储类

register 存储类用于定义存储在寄存器中而不是 RAM 中的局部变量。这意味着变量的最大尺寸等于寄存器的大小（通常是一个字），且不能对它应用一元的 ‘&’ 运算符（因为它没有内存位置）。
register 存储类定义存储在寄存器，所以变量的访问速度更快，但是它不能直接取地址，因为它不是存储在 RAM 中的。在需要频繁访问的变量上使用 register 存储类可以提高程序的运行速度。

{
   register int  miles;
}

3、static 存储类

static 存储类指示编译器在程序的生命周期内保持局部变量的存在，而不需要在每次它进入和离开作用域时进行创建和销毁。因此，使用 static 修饰局部变量可以在函数调用之间保持局部变量的值。
static 修饰符也可以应用于全局变量。当 static 修饰全局变量时，会使变量的作用域限制在声明它的文件内。
全局声明的一个 static 变量或方法可以被任何函数或方法调用，只要这些方法出现在跟 static 变量或方法同一个文件中。
静态变量在程序中只被初始化一次，即使函数被调用多次，该变量的值也不会重置。

#include <stdio.h>

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

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

4、extern 存储类

extern 存储类用于定义在其他文件中声明的全局变量或函数。当使用 extern 关键字时，不会为变量分配任何存储空间，而只是指示编译器该变量在其他文件中定义。
extern 存储类用于提供一个全局变量的引用，全局变量对所有的程序文件都是可见的。当您使用 extern 时，对于无法初始化的变量，会把变量名指向一个之前定义过的存储位置。
当您有多个文件且定义了一个可以在其他文件中使用的全局变量或函数时，可以在其他文件中使用 extern 来得到已定义的变量或函数的引用。可以这么理解，extern 是用来在另一个文件中声明一个全局变量或函数。
extern 修饰符通常用于当有两个或多个文件共享相同的全局变量或函数的时候，如下所示：

文件1：main.c

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

文件2：support.c

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

执行结果

count is 5