标识符：
标识符使用来标识程序中的某个对象的名字的，这些对象可以是语句、数据类型、函数、变量、常量、数组等。
因为，C语言对大小写字符敏感，所以在编写程序时要注意大小写字符的区分。例如：对于sec和SEC这两个标识符来说，C语言会认为这是两个完全不同的标识符。
另外，C语言程序中的标识符命名应做到简洁明了、含义清晰。这样便于程序的阅读和维护。例如在比较最大值时，最好使用max来定义该标识符。
关键字 ：
在c语言编程中，为了定义变量、表达语句功能和对一些文件进行预处理，还必须用到一些具有特殊意义的字符，这就是关键字。
关键字已被编译系统本身使用，所以用户编写程序时不能够使用这些关键字来作为标识符。 C语言中关键字主要有以下二类：
- 数据类型：char，double，enum，float，int，long，short，struct，union，unsigned，void，signed，volatile，auto，extern，register，static，const
- 语句 ：if，return，break，case，continue，default，do，else，for，goto，switch，while
标识符和关键字的区别
关键字就是C语言中已经被赋予特定意义的一些单词.不可以把这类词作为名字来用.(类似在中国，现实生活中的“社会主义”已经被赋予特定意义，不能用于产品、公司或人的名字)
标识符就是用给”变量、函数和文件”等起的名字.简单地说,标识符就是一个名字.
变量是内存中的一块区域，在程序运行过程中可以修改这块区域中存放的数值。变量由两个要素构成：变量的名称和变量的类型。变量的名称是这个内存区域的唯一标识。变量的类型决定了这个内存区域的的大小、对所存储数值的类型要求。在程序中，有三种与变量有关的语句：变量的定义、变量的赋值和变量的引用。
变量的定义
如下的语句定义了一个变量：
int number;
这里‘number’是变量名，‘int’代表该变量是整数类型的变量，‘;’表示定义语句结束。
在目前流行的机器配置下，整型变量一般占4个字节的内存空间。变量的名字是由编写程序的人确定的，它一般是一个单词或用下划线连接起来的一个词组，说明变量的用途。在C/C++语言中变量名是满足如下规定的一个符号序列：1) 由字母、数字或（和）下划线组成；2) 第一个符号为字母或下划线。需要指出的是，同一个字母的大写和小写是两个不同的符号。所以，team和TEAM是两个不同的变量名。
定义变量时，也可以给它指定一个初始值。例如：
- int numberOfStudents = 80;
- 对于没有指定初始值的变量，它里面的内容可能是任意一个数值。
- 变量一定要先定义，然后才能使用。
变量的赋值
给变量指定一个新值的过程称为变量的赋值，通过赋值语句完成。例如：
number = 36 ;
表示把36写入变量number中。下面是一段代码，试着分析代码”定义时的变量的值；每次赋值后，变量的值“
int temp; int count; temp = 15; count = temp; count = count +1; temp = count;变量的引用
变量的引用既变量的使用，变量里存储的数据可以参与表达式的运算，或赋值给其它变量。这一过程称为变量的引用。例如下面是变量 total 的定义和使用：
int total = 0 ; int p1 = 5000 ; int p2 = 300 ; int p3 = 1000 ; int p4 = 1000 ; total = p1 + p2 + p3 + p4 ;
其中，最后一个赋值语句表示把变量‘p1’，‘p2’，‘p3’和‘p4’的值取出来相加，得到的和赋给变量‘total’。最后一句执行后，‘total’的值变为7300。
全局变量和局部变量
定义变量时，可以将变量写在一个函数内部，这样的变量叫局部变量；也可以将变量写在所有函数的外面，这样的变量叫全局变量。全局变量在所有函数中均可以使用，局部变量只能在定义它的函数内部使用。请看下面的程序：
int n1 = 5, n2 = 10; void Function1() { int n3 = 4; n2 = 3; } void Function2() { int n4; n1 = 4; n3 = 5; //编译出错 } int main() { int n5; int n2; if (n1 == 5) { int n6; n6 = 8; } n1 = 6; n4 = 1; //编译出错 n6 = 9; //编译出错 n2 = 7; return 0; }上面的程序中，n1、n2是全局变量，所以在所有的函数中均能访问，例如语句5、10、21；n3是在函数Function1里定义的，在其他函数中不能访问，因此语句11会导致“变量没定义”的编译错误；语句22也是一样。
一个局部变量起作用的范围（称为“作用域”），就是从定义该变量的语句开始，到包含该变量定义语句的第一个右大括号为止，因此语句19定义的变量n6，其作用域就是从语句19开始直到语句20的位置。在语句23中试图访问n6，导致“变量没定义”的编译错误。
如果某局部变量和某个全局变量的名字一样，那么在该局部变量的作用域中，起作用的是局部变量，全局变量不起作用。例如语句16定义的局部变量n2和全局变量n2同名，那么语句24改变的就是局部变量n2的值，不会影响全局变量n2。
前面我们介绍了变量的定义语句，就下来我们介绍几个常用的数据类型：
int nNumber;
此处的“int”表示了变量 nNumber 的“数据类型”，它说明nNumber是一个“整型变量”，即nNumber中存放的是一个整数。“数据类型”能够说明一个变量表示什么样的数据(整数，浮点数，还是字符等)。不同数据类型的变量，占用的存储空间大小不同。除了“int”以外，C/C++中还有其他一些基本数据类型，现列举其中几个如下：
int： 整型。int型变量表示一个整数，其范围是 -231 －231-1，占用4个字节。
long：长整型。和 int 类型一样，也占用4个字节。
short：短整型。short型变量表示一个整数，但它占用2个字节，因而能表示的数的范围是 -215 －215-1。
unsigned int： 无符号整型。unsigned int 类型的变量表示一个非负整数，占用4个字节，能表示的数的范围是：0 －232-1
unsigned long ：和unsigned int一样。
unsigned short： 无符号短整型。unsigned short 类型的变量表示一个非负整数，占用2个字节，能表示的数的范围是：0 －216-1。
本书中，我们将上面几种类型统称为“整数类型”。
char ： 字符型。char类型的变量表示一个字符，如’a’,’0’等。占用1个字节。字符型变量存放的实际上是字符的Ascii码。比如’a’的Ascii码是97，即16进制的0x61，那么如果有：
char c = ‘a’;
则实际上c中就存放着16进制数0x61，或二进制数01100001。
unsigned char：无符号字符型。unsigned char 类型的变量表示一个字符，占用1个字节。
float ：单精度浮点型。float类型的变量表示一个浮点数（实数），占用4个字节。
double ：双精度浮点型。double类型的变量也表示一个浮点数，但它占用8个字节，因而精度比float类型高。
以上的“int”、“double”、“short”、”unsigned char”等标识符，都是“类型名”。C++中的“类型名”可以由用户定义，后文“结构”一节会进一步阐述。
在赋值语句中，如果等号左边的变量类型为T1，等号右边的变量或常量类型为T2，T1和T2不相同，那么编译器会将等号右边的变量或常量的值，自动转换为一个T1类型的值，再将此值赋给等号左边的变量。这个过程叫做“自动类型转换”。自动类型转换不会改变等号右边的变量。能进行自动类型转换的前提是，T1和T2是两个兼容的类型。上面提到的所有类型，正好都是两两互相兼容的。但是后面会碰到一些类型，比如指针类型，结构类型，它们和上述所有的类型都不兼容。如果等号左边是个整型变量，等号右边是个“结构类型”的变量，这样的赋值语句在编译的时候就会报错。
下面以一个程序来说明上述数据类型之间的自动转换：
1. #include <stdio.h>
2. int main()
3. {
4. int n1 = 1378;
5. short n2;
6. char c = ‘a‘;
7. double d1 = 7.809;
8. double d2;
9. n2 = c; //n2变为97
10. printf("c=%c,n2=%d\n", c, n2);
11. c = n1; //c变为 ’b’
12. printf("c=%c,n1=%d\n", c, n1);
13. n1 = d1; //n1变为7
14. printf("n1=%d\n", n1);
15. d2 = n1; //d2变为7
16. printf("d2=%f", d2);
17. return 0;
18. }
上面程序的输出结果是：
c=a,n2=97
c=b,n1=1378
n1=7
d2=7.000000
该程序中printf语句的用法比较复杂，请参看 2.10.1 节关有printf语句的详细说明。
执行语句9时，由于变量c内存放的是字符’a’的Ascii码，即十进制整数97，因此本条赋值语句使得n2的值变为97。
语句11中，等号的左边是char类型的变量、右边是int类型的变量。语句执行时，先将右边的int值自动转换成一个char类型的值，再赋值给c。由于char类型的变量只要1个字节，所以自动转换的过程就是丢弃n1的高3字节，只取n1中最低的那个字节赋值给c。n1的值是1378，表示成十六进制是 562，最低的字节是 0x62。本条语句执行完毕后，c的值就是0x62，换算成十进制就是98。98是字母’b”的Ascii码，因此，本语句执行后，c中就存放着字母’b’。需要指出的是，本语句的自动转换过程不会改变n1的值。
语句13执行时，须将浮点数值7.809自动转换成一个整型值，再赋给n1。在C/C++中，浮点数自动转换成整数的规则是去掉小数部分，因此n1的值变为7。d1的值不改变。
思考题：1.3.1:假定char类型的变量c中存放着一个’w’之前的小写字母，请写一条赋值语句，使得c变为其后的第4个字母（比如，将c从’a’变成’e’）。解答见后。
提示：小写字母的Ascii码是连续的。
常量是程序需要访问的一个数据，它在程序的运行过程中不发生改变。常量有两种表现形式：直接写出值，或用 #define 语句为数据定义一个由符号组成的标识符，标识符的命名规则与变量的命名规则相同。不同的数据类型有不同形式的常量。例如：123，-56，0，38，-1是整数类型的常量；1.5，23.6， 0.0， -0.6789， 100.456是浮点类型的常量；‘a‘，‘p‘ ，‘0‘ ，‘￥‘ ，‘#‘ 是字符类型的常量；“abc”，“definitely”，“1234”，“0.6”，“AE4%(Ap)”等是字符串类型的常量。这些都是直接给出数据值的常量，它们的类型可以很容易地从数据形式上判断。另一种用#define 语句，为需要访问的数据指定一个容易理解的名字（标识符），例如：
#define MAPLENGTH 100
#define MAPWIDTHTH 80
void main( ){
int mapSize;
mapSize = MAPLENGTH * MAPWIDTH ;
printf(“The map size is %d\n”, mapSize);
}
这段代码中 MAPLENGTH 是一个整数类型的常量，它的值是100。在定义语句之后，所有出现符号MAPLENGTH的地方，都等效于出现数值100。同样地，MAPWIDTH 也是一个整数类型的常量，它的值是80。这段程序的运行结果是输出一个整数8000。
C/C++语言中，整数类型常量还可以有八进制、十六进制的写法。
八进制常量以数字“0”开头的，比如 0123就是八进制的123。0987是不合法的常量，因为以0开头代表是八进制数，而八进制数中是不能出现数字8和9的。
十六进制常量以“0x”开头。比如，0x12就是16进制的12，换算成十进制就是18。0xfd0678、0xff44f 都是合法的十六进制常量。十六进制表示法中，用a代表10、b代表11、c代表12、d代表13、e代表14、f代表15。这几个字母大、小写均可。由于16进制中的每一位正好对应于二进制的4位，因此，十六进制常量用起来十分方便，也非常有用。
有一些字符常量的写法比较特殊，比如单引号应写为 ‘\‘‘ ，“\”应写为 ‘\\‘。
思考题 1.4: 什么样的常量在程序运行期间会象变量一样，需要用一片内存空间来存放，什么样的常量不需要？
C/C++语言中的“+”、“-” “*” “/”等符号，表示加、减、乘、除等运算，这些表示数据运算的符号称为“运算符”。运算符所用到的操作数个数，称为运算符的“目数”。比如，“+”运算符需要两个操作数，因此它是双目运算符。
将变量、常量等用运算符连接在一起，就构成了“表达式”。如“n+5”、“4-3+1”。实际上，单个的变量、常量也可以称为“表达式”。表达式的计算结果称为“表达式的值”。如表达式“4-3+1”的值就是2，是整型的。如果 f 是一个浮点型变量，那么表达式“f”的值就是变量f的值，其类型是浮点型。
Ｃ/C++语言的运算符有赋值运算符、算术运算符、逻辑运算符、位运算符等多类。常用的介绍如下。
算术运算符用于数值运算。包括加(+)、减(-)、乘(*)、除(/)、求余数(%)、自增(++)、自减(--)共七种。
求余数的运算符“%”也称为模运算符。它是双目运算符，两个操作数都是整数类型的。a % b 的值就是a除以b的余数。
C/C++的除法运算符有一些特殊之处，即如果a、b是两个整数类型的变量或者常量，那么a/b的值是a除以b的商。比如，表达式 “5/2”的值是2，而不是2.5。请看下面的程序片断：
1. int main()
2. {
3. int a = 10;
4. int b = 3;
5. double d = a/b;
6. printf("%f\n", d);
7. d = 5/2;
8. printf("%f\n", d);
9. d = 5/2.0;
10. printf("%f\n", d);
11. d = (double)a/b;
12. printf("%f\n", d);
13. return 0;
14. }
上面程序的输出结果是：
3.000000
2.000000
2.500000
3.333333
语句5中，由于a、b都是整型，所以表达式a/b 的值也是整型，其值是3，因此d的值就变成3.0。
语句7和语句5类似，执行后d的值变为2.0。
语句9中，要求5除以2的精确值，为此要将5或者2表示成浮点数。除法运算中，如果有一个操作数是浮点数，那么结果就也会是较为精确的浮点数。因此表达式5/2.0 的值是2.5。
语句11求 a除以b的较为精确的小数形式的值。“(double)”的是一个“强制类型转换运算符”，它是一个单目运算符，能将其右边的操作数强制转换成double 类型。用此运算符先将a的值转换成一个浮点数值，然后再除以b，此时算出来的结果就是较为精确的浮点型的了。
自增运算符“++” 用于将整型或浮点型变量的值加1。只有一个操作数，是单目运算符。它有两种用法：
用法1:
变量名 ++;
用法 2：
++变量名;
这两种用法都能使得变量的值加1，但它们是有区别的，请看例子：
1. #include <stdio.h>
2. main()
3. {
4. int n1 , n2 = 5;
5. n2 ++;
6. ++ n2;
7. n1 = n2 ++;
8. n1 = ++ n2;
9. }
语句5 执行后，n2的值是6；
语句6执行后，n2的值是7；
语句7执行过程，是先将n2的值赋给n1，然后再增加n2的值，因此语句7执行后，n1的值是7，n2的值是8。也可以说，表达式“n2++”的值，就是n2加1以前的值；
语句8 的执行过程，先将n2的值加1，然后再将n2的新值赋给n1。因此语句8执行后，n1的值是9，n2的值也是9。也可以说，表达式“++n2”的值，就是n2加1以后的值；
语句7和8体现了“++”写在变量前面和后面所造成的不同。
自减运算符“--” 用于将整型或浮点型变量的值减1。它的用法和“++”相同，不再赘述。
赋值运算符用于对变量进行赋值，分为简单赋值(=)、复合算术赋值(+=, -=, *=, /=, %=)和复合位运算赋值(&=, |=, ^=, >>=, <<=)三类共十一种。
表达式“a = b”的值就是a，类型和a的类型一样。因此，可以写：
int a, b;
a = b = 5;
上面这条语句先将b的值赋为5；然后求得b=5这个表达式的值5，再赋值给a。
a += b 等效于 a = a + b，但是前者执行速度比后者快。
-=、*=、/=、%= 的用法和 += 类似。
关系运算符用于数值的大小比较。包括大于(>)、小于(<)、等于(==)、 大于等于(>=)、小于等于(<=)和不等于(!=)六种。他们都是双目运算符。
关系运算符运算的结果是整型，值只有两种：0或非0。0代表关系不成立，非0代表关系成立。
比如表达式“3>5”，其值就是0，代表该关系成不成立，即运算结果为假；表达式“3==3”，其值就是非0，代表该关系成立，即运算结果为真。至于这个非0值到底是多少，C/C++语言没有规定，我们编程的时候也不需要关心这一点。C/C++语言中，总是用0代表“假”，用非0代表“真”，在后面的 2.7 节会看到其用法。
请看下面的例子：
main()
{
int n1 = 4, n2 = 5, n3;
n3 = n1 > n2; // n3 的值变为 0
n3 = n1 < n2; // n3 的值变为某非0值
n3 = n1 == 4; // n3 的值变为某非 0 值
n3 = n1 != 4; // n3 的值变为0
n3 = n1 == 5; // n3 的值变为0
}
逻辑运算符用于数值的逻辑操作。包括与(&&)、或(||)、非(!)三种。前二者是双目运算符，第三个是单目运算符。其运算规则如下：
与(&&)
当且仅当表达式exp1和表达式exp2的值都为真（非0）时，“exp1 && exp2” 的值为真，其他情况，“exp1 && exp2”的值均为假。
例如，如果 n = 4，那么“n > 4 && n < 5 ”的值就是假，“n >= 2 && n < 5”的值就是真。
或(||)
当且仅当表达式exp1和表达式exp2的值都为假（就是0）时，“exp1 || exp2” 的值为假，其他情况，“exp1 || exp2”的值均为真。例如，如果 n = 4，那么“n > 4 || n < 5 ”的值就是真，“n <= 2 || n > 5”的值就是假。
非(!)
如果表达式exp的值为真，那么“ ! exp”的值就是假；如果exp的值为假，那么“ ! exp”的值就是真。比如，表达式“! (4 < 5 )”的值就是假。
函数是C语言中的一种程序组件单位。一个函数通常代表了一种数据处理的功能，由函数体和函数原型两部分组成。函数原型为这个数据处理功能指定一个标识符号(函数的名称)、说明被处理数据的组成及其类型、处理结果的类型。函数体由一组语句组成，具体实现数据处理的功能。这称为函数的定义。在某段程序中，一个函数可以被当作一个表达式来运行，称为函数的调用。函数的定义并不执行函数体中的语句，只是声明该函数包含这些语句、以及这些语句的运行顺序。函数在被调用之前，必须说明它的原型。被函数处理的数据一般作为函数的参数，在函数调用时确定它们的值。但是在函数体的语句中，可以直接访问函数的参数。函数运行后可以把它的结果返回给调用它的程序。
如果一个程序代码中需要多次实现同一种数据处理功能，通常将这个数据处理功能定义成一个函数，开发成一个单独程序组件。使得整个程序开起来更简洁。此外，当一个程序代码段实现的功能很复杂时，也常常将这个功能分解成若干个相对简单的子功能。每个子功能分别作为一个函数，用一个程序组件实现。
函数的定义形式如下：
返回值类型 函数名 （[参数1类型 参数名1， 参数2类型 参数名2，……]）{
语句1； // 语句可能与参数有关
语句2； // 语句可能与参数有关
……
return 返回值； // 如果返回值类型为void，则不用返回语句
}
其中，返回值类型表示该函数如果被调用，它执行完之后向调用它的程序返回何种数据类型的值。函数名是程序员自己定义的、能够表明函数用途的标识符号，命名规则与变量的命名规则相同。参数是可选的，有些函数没有参数，有些可以有一至多个参数。每个参数都应说明其类型，以便调用它的程序可以填入正确的参数值。小括号和大括号是必须的。语句中可以把参数当作变量来使用。下面是一个函数定义的例子：
int add(int x, int y){
return x+y;
}
这个函数的函数名是add，它有两个参数分别是整数类型的x和整数类型的y；它的返回值类型也是整型，功能是计算两个整数的和，执行的结果是将计算出来的和返回给调用它的程序。两个参数x和y的值是调用它的函数给定的。
函数定义也可以分成两部分，即函数原型说明和函数体。函数原型说明必须在函数调用之前。函数体可以紧跟着函数原型说明，也可以放在程序中间的位置。例如：
int multiple(int x, int y); // 函数说明
void main(){
int a=0, b=0;
scanf(“%d %d”, &a, &b);
printf(“%d\n”, multiple(a, b)); // 函数调用
}
int multiple(int x, int y){ // 函数体
return x * y;
}
在一段程序中引用一个已经定义过的函数称为函数的调用。在调用函数时要给出每个参数的取值。如果函数有返回值，可以定义一个与返回值类型相同的变量，存储函数的返回值。下面是函数调用的例子：
int add(int x, int y){
return x+y;
}
void main(){
int n1=5, n2=6, n3;
n3=add(n1, n2);
printf(“%d\n”, n3);
}
这段程序，调用函数add计算n1加n2的值，并将计算结果存入n3。最后输出n3的值。这里要注意的是：如果函数的返回值是整型的，则函数调用表达式本身可以被看作是一个整数，它可以出现在任何整数可以出现的地方。其它类型的返回值也是一样。
有返回值的函数调用可以出现在表达式中，比如 n3 = add(n1, n2) + 7； 也是合法的语句。
函数调用可以看作在程序组件A的执行过程中，跳出A的代码段，转去执行另外一段代码B，等B执行完之后，再回到A中函数调用的位置，继续执行后面的语句。在函数调用的过程中，程序组件A可以通过参数向程序组件B传送信息；程序组件B结束后，可以通过返回值将其执行结果传回程序组件A。
参数作为数值传递给被调用的函数，在函数内部等同于内部变量。下面是一个例子：
int max(int a, int b){
if(a>=b) return a;
else return b;
}
void main( ){
int x=0, y=0, z=0;
x = 20;
y = 45;
int z = max(x, y);
……
}
在主函数开始执行之前系统为它分配了空间存放变量x, y, z。第一条赋值语句结束后，x的值修改为20；第二条赋值语句结束后，y的值修改为45；执行到第三条赋值语句时，“=”号右边是函数调用，于是装入函数max的代码。max函数所在的程序段，系统为参数a, b分配了空间（注意：参数的名字是独立于调用它的程序的），并将调用时的参数值填入分配的空间。也就是说调用函数时，将数值45和20传给被调用的函数。这时main暂时停止执行，max开始执行，它执行的结果是将参数b的值45通过return语句返回给main。main接收到max返回的45，并且把它赋值给变量z，此时z变量的内容修改为45。程序继续执行。这里需要注意的是：在max函数中对a，b的任何操作不影响x，y的值。
函数执行完以后可以向调用它的程序返回一个值，表明函数运行的状况。很多函数的功能就是对参数进行某种运算，之后通过函数返回值给出运算结果。函数的返回值可以有不同的类型，返回值类型在函数定义时说明。下面是一些函数定义的例子：
int min(int x, int y)； // 返回值类型为int，有两个整型参数，函数名为min
double calculate( int a, double b);
// 返回值类型为double，有一个整型参数，一个double 型参数，函数名为calculate
char judge(void); // 返回值类型为char，没有参数，函数名为judge
void doit(int times);
// 返回值类型为void，表示不返回任何值，有一个整型参数，函数名为doit
C/C++语言标准中，规定了完成某些特定功能的一些函数，这些函数是不同厂商的C/C++语言编译器都会提供的，并且在用C/C++语言编程时可以直接调用的。这样的函数统称为C/C++标准库函数。比如，前面看到的printf函数就是一例。
函数必须先声明原型，然后才能调用。C/C++语言规定，不同功能的库函数，在不同的头文件里进行声明。头文件就是编译器提供的，包含许多库函数的声明，以及其他内容（比如用#define语句定义一系列标识符）的文件。头文件的后缀名是.h。编程时若要使用某个库函数，就需要用#include 语句将包含该库函数原型声明的头文件，包含到程序中，否则编译器就会认为该函数没有定义。比如，printf函数就是在 stdio.h 这个头文件中声明的，因此若要使用该函数，那么就要在程序开头加入：
#include <stdio.h>
C/C++语言中，有一类库函数，称之为标准输入输出函数，可以用来从键盘读取键入的字符，以及将字符在屏幕上输出。这些函数的声明都包含在头文件 stdio.h中。我们介绍以下两个主要的标准输入输出函数：
printf
scanf
printf函数的作用是将一个或多个字符按照程序员指定的格式输出到屏幕上。printf函数调用的一般形式为：
printf(“格式控制字符串”，待输出项1，待输出项2……)
其中格式控制字符串用于指定输出格式，是用一对双引号括起来的。
例如：
printf( “x = %d” , 50);
上面这条语句中，格式控制字符串就是“x = %d”，待输出项就是 50。其输出结果是：
x = 50
象”%d”这样由一个“%”和其后一个（或多个）字符组成的字符串，称为“格式控制符”。它说明待输出项的类型、输出形式（比如以十进制还是二进制输出，小数点后面保留几位等等）。“%d”表示其对应的待输出项是整型。
“%”和特定的一些字符组合在一起，构成“格式控制符”。常见的格式控制符有：
%d 要输出一个整数
%c 要输出一个字符
%s 要输出一个字符串
%x 要输出一个十六进制整数
%u 要输出一个无符号整数（正整数）
%f 要输出一个浮点数。
“格式控制字符串”中， “格式控制符”的个数应该和待输出项的个数相等，并且类型须一一对应。“格式控制字符串”中非格式控制符的部分，则原样输出。例如：
printf(“Name is %s, Age = %d, weight = %f kg, 性别：%c, code = %x” ,
“Tom”, 32, 71.5, ‘M’, 32 );
输出结果是：
Name is Tom, Age = 32, weight = 71.500000 kg, 性别：M, code = 20
最后的待输出项“32” 对应的输出结果是“20”。因为它对应的输出控制符是“%x”，这就导致十进制数“32”被以十六进制的形式输出为“20”。
如果就是想输出“%d”这样一个字符串，怎么办呢？做法是，想输出一个“%”，就要连写两个“%”。例如：
printf(“a%%d”);
输出结果是：
a%d
如果想让输出换行，则需输出一个换行符 “\n”。如：
printf(“What’s up?\nGreat!\nLet’s go!”);
输出结果是：
What’s up?
Great!
Let’s go!
scanf函数的一般形式为：
scanf(“格式控制字符串”，变量地址1, 变量地址2……);
scanf函数的作用是从键盘接受输入，并将输入数据存放到变量中。“变量地址”的表示方法是在变量前面加”&”字符。“格式控制字符串”说明要输入的内容有几项、以及这几项分别是什么类型的。函数执行完后，输入内容的每一项分别被存放到各个变量中。例如：
#include <stdio.h>
main()
{
char c;
int n;
scanf("%c%d",&c, &n);
printf("%c,%d", c, n);
}
scanf语句中的“%c%d”说明待输入的数据有两项，第一项是一个字符，第二项是一个整数。这两项之间可以用空格或换行进行分隔，也可以不分隔。scanf函数会等待用户从键盘敲入数据，用户输完后必须再敲回车，scanf函数才能继续执行，将两项输入数据存放到变量c和n中。上面的程序，不论敲入“t456回车”，还是“t空格456回车”还是“t回车456回车”，结果都是一样的。输出结果为：
t,456
即字符’t’被读入，存放在变量c中，”456”被读入，存放于变量n中。
如果要输入的是两个整数，那么这两个整数输入的时候必须用空格或回车分隔。
下面的程序，提示用户输入矩形的高和宽，然后输出其面积。
#include <stdio.h>
main()
{
int nHeight, nWidth;
printf("Please enter the height:\n");
scanf("%d",& nHeight);
printf("Please enter the width:\n");
scanf( "%d",& nWidth);
printf("The area is: %d", nHeight * nWidth);
}
试着运行一下，看一看结果。
定义变量时，可以将变量写在一个函数内部，这样的变量叫局部变量；也可以将变量写在所有函数的外面，这样的变量叫全局变量。全局变量在所有函数中均可以使用，局部变量只能在定义它的函数内部使用。请看下面的程序：
例程 2.11.cpp：
27. int n1 = 5, n2 = 10;
28. void Function1()
29. {
30. int n3 =4;
31. n2 = 3;
32. }
33. void Function2()
34. {
35. int n4;
36. n1 = 4;
37. n3 = 5; //编译出错
38. }
39. int main()
40. {
41. int n5;
42. int n2;
43. if( n1 == 5 ) {
44. int n6;
45. n6 = 8;
46. }
47. n1 = 6;
48. n4 = 1; //编译出错
49. n6 = 9; //编译出错
50. n2 = 7;
51. return 0;
52. }
上面的程序中，n1、n2是全局变量，所以在所有的函数中均能访问，例如语句5、10、21；n3是在函数Function1里定义的，在其他函数中不能访问，因此语句11会导致“变量没定义”的编译错误；语句22也是一样。
一个局部变量起作用的范围（称为“作用域”），就是从定义该变量的语句开始，到包含该变量定义语句的第一个右大括号为止，因此语句19定义的变量n6，其作用域就是从语句19开始直到语句20的位置。在语句23中试图访问n6，导致“变量没定义”的编译错误。
如果某局部变量和某个全局变量的名字一样，那么在该局部变量的作用域中，起作用的是局部变量，全局变量不起作用。例如语句16定义的局部变量n2和全局变量n2同名，那么语句24改变的就是局部变量n2的值，不会影响全局变量n2。
原文：http://www.cnblogs.com/jlxuqiang/p/3575188.html
