int giants=5;  //文件作用域，外部链接
static int dodgers=3;  //文件作用域，内部链接
int main()
{
    ......
}

和该文件属于同一程序的其他文件可以使用变量giants，变量dodgers是该文件私有的，但是可以被该文件中的任一函数使用。

2、存储时期
一个C变量有以下两种存储时期之一：静态存储时期和自动存储时期。如果一个变量具有静态存储时期，它在程序执行期间将
一直存在。具有文件作用域的变量具有静态存储时期。注意对于具有文件作用域的变量，关键词static表明链接类型，并非
存储时期。一个使用static声明了的文件作用域变量具有内部链接，而所有的文件作用域变量，无论它具有内部链接，还是
具有外部链接，都具有静态存储时期。
具有代码块作用域的变量一般情况下具有自动存储时期，在程序进入定义这些变量的代码块时，将为这些变量分配内存；当
退出这个代码块时，分配的内存将被释放。

      5个存储类
 存储类                           时期     作用域     链接     声明方式
 自动                              自动     代码块     空         代码块内
 寄存器                           自动     代码块     空         代码块内，使用关键字register
 具有外部链接的静态            静态     文件       外部     所有函数之外
 具有内部链接的静态            静态     文件       内部     所有函数之外，使用关键字static
 空链接的静态                   静态     代码块     空         代码块内，使用关键字static
 
如果在内层代码块定义了一个具有和外层代码块变量同一名的变量，那么在内层代码块定义的名字是内层代码块内使用的变量，
我们称之为内层定义覆盖了外部定义，但当运行离开内层代码块时，外部变量重新恢复作用。
如：

#include<stdio.h>
int main()
{
    int x=30;
    printf("x in outer block :%d\n",x);
    {
        int x=77;
        printf("x in inner block :%d\n",x);
    }
    printf("x in outer block :%d\n",x);
    while(x++<33)
    {
        int x=100;
        x++;
        printf("x in while loop :%d\n",x);
    }
    printf("x in outer block :%d\n",x);

    return 0;
}

x in outer block :30
x in inner block :77
x in outer block :30
x in while loop :101
x in while loop :101
x in while loop :101
x in outer block :34

#include<stdio.h>
void trystat(void);
int main()
{
    int count;

    for(count=1;count<=3;count++)
    {
        printf("Here comes iteration %d:\n",count);
        trystat();
    }

    return 0;
}
void trystat(void)
{
    int fade=1;
    static int stay=1;

    printf("fade=%d and stay=%d\n",fade++,stay++);
}

Here comes iteration 1:
fade=1 and stay=1
Here comes iteration 2:
fade=1 and stay=2
Here comes iteration 3:
fade=1 and stay=3

int wontwork(static flu);  //不允许

int Hocus;
int magic();
int main()
{
    int Hocus;    //声明Hocus，默认为自动变量
    
}
int Pocus;
int magic()
{
    auto int Hocus;    //把局部变量Hocus显式第声明为自动变量
    
}

上面代码中，创建了4个独立的变量，main()中的Hocus默认为自动变量，而且是main()的局部变量，magic()中的Hocus被显式第
声明为自动变量，只对magic()可见。外部变量Hocus对main()或magic()不可见，但对文件中其他不单独用于局部Hocus的函数都
可见。最后，Pocus是一个外部变量，对magic()可见而对main()不可见，因为Pocus的声明在main()之后。

3、外部变量初始化
不同与自动变量的是，如果您不对外部变量进行初始化，它们将自动被赋初值0，这一原则也使用于外部定义的数组元素。不同于
自动变量，只可以用常量表达式来初始化文件作用域变量：

int x=10;    //可以
int y=3+20;    //可以
size_t z=sizeof(int);    //可以
int x2=2*x;    //不可以，x为变量

int tern=1;
main()
{
    external int tern;
}

extern int tern;
int main()
{
}

extern char permis='Y';

因为关键字extern的存在标志着这是一个引用声明，而非定义声明。

5、存储类说明符
5个：auto、register、static、extern以及typedef。
自动变量具有代码块作用域、空链接和自动存储时期。它们是局部的，为定义它们的代码块（通常为一个函数）所私有。寄存器
变量与自动变量具有相同属性，但编译器可能使用速度更快的内存或寄存器来存储它们。无法获取一个寄存器变量的地址。
具有静态存储时期的变量可能具有外部链接、内部链接或空链接。当变量在文件的所有函数之外声明，它是一个具有文件作用域
的外部变量，具有外部链接和静态存储时期。如果在这样的声明中再加上关键字static，将获得一个具有静态存储时期、文件
作用域和内部链接的变量。如果在一个函数内使用关键字static声明变量，变量将具有静态存储时期、代码块作用域和空链接。

 1#include<stdio.h>
 2int main()
 3{
 4    int jane,tarzan,cheeta;
 5    
 6    cheeta=tarzan=jane=68;
 7    printf("cheeta=%d tarzan=%d jane=%d \n",cheeta,tarzan,jane);
 8    
 9    return 0;
10}

1cheeta=68 tarzan=68 jane=68

2、优先级
增量和减量运算符有很高的优先级；只有圆括号比它们的优先级高。所以x*y++代表(x)*(y++)而不是(x*y)++。
n=(y+n++)*6，只有当使用了n之后，n的值才增加。优先级告诉我们++只属于n，而不属于y+n。

3、语句
 声明语句  int toes;
 赋值语句  toes=12;
 函数调用语句 printf("%d\n",toes);
 结构化语句  while(toes<20) toes=toes+2;
 空语句   ;
 复合语句  在花括号里的语句
 
4、类型转换

 1#include<stdio.h>
 2int main()
 3{
 4    char ch;
 5    float fl;
 6    int i;
 7    
 8    fl=i=ch='C';                                                          //1
 9    printf("ch=%c fl=%2.2f i=%d\n",ch,fl,i);                    //2
10    ch=ch+1;                                                            //3
11    i=fl+2*ch;                                                           //4
12    fl=2.0*ch+i;                                                        //5      
13    printf("ch=%c,i=%d,fl=%2.2f\n",ch,i,fl);                   //6
14    
15    return 0;
16}

1ch=C fl=67.00 i=67
2ch=D,i=203,fl=339.00

2、您无须亲自把空字符插入数组中，scanf()在读取插入时会替您完成任务。

3、scanf()开始读取输入以后，会在遇到到第一个空白字符、制表符、或者换行符处停止读取。使用%s到scanf()只会把一个单词而不是把整个句子作为字符串
输入。可以使用其他读取输入函数如gets()来处理一般的字符串。

4、sizeof运算符，以字节为单位给出数据到大小，指存储空间。
strlen()函数以字符为单位给出字符串的长度，不包括'\0'在内。如字符串"abc"长度为3，但是占用的空间为4.

5、用符号常量到好处为：
 a、一个名字比一个数字告诉您的信息多；
 b、假如您在多个地方使用同一个常量，修改方便。
 
6、#define NAME value
没有使用分号因为这是一个替代机制而不是C的语句。

7、转换说明符：
 %a或者%A 浮点数、十六进制数字
 %g或者%G 根据数值不同自动选择%f或%e或%E
 %i  有符号十进制整数（与%d相同）
 %%  打印一个百分号
 
8、printf()的标志
 标志           意义
 -                  左对齐
 +                 有符号的值若为正，则显示带加号到符号；若为负，则带减号到符号
 （空格）   有符号的值若为正，则显示时带前导空格（但是不显示符号）；若为负，则带减号符号。+标志会覆盖空格标志
 0                 对于所有的数字格式，用前导零而不是用空格填充字符宽度。如果出现-标志或者指定来精度则忽略该标志。
 
例子：

 1#include<stdio.h>
 2
 3#define VAL_1 123
 4#define VAL_2 -123
 5int main()
 6{
 7    printf("*%10d*\n",VAL_1);    //默认右对齐
 8    printf("*%10d*\n",VAL_2);    //默认右对齐
 9    printf("*%-10d*\n",VAL_1);    //-
10    printf("*%-10d*\n",VAL_2);    //-
11    printf("*%+d*\n",VAL_1);    //+
12    printf("*%+d*\n",VAL_2);    //+
13    printf("*% d*\n",VAL_1);    //<空格>
14    printf("*% d*\n",VAL_2);    //<空格>
15    printf("*%010d\n",VAL_1);    //0
16    printf("*%010d\n",VAL_2);    //0
17
18    return 0;
19}

 1*       123*
 2*      -123*
 3*123       *
 4*-123      *
 5*+123*
 6*-123*
 7* 123*
 8*-123*
 9*0000000123
10*-000000123

 1#include<stdio.h>
 2
 3#define STR "Authentic imitation!"
 4
 5int main()
 6{
 7    printf("/%24.5s/\n",STR);
 8    printf("/%-24.5s/\n",STR);
 9
10    return 0;
11}

1/                   Authe/
2/Authe                   /

说明：
格式说明符中到.5告诉printf()只打印5个字符。

9、不匹配的转换
代码1：

 1#include<stdio.h>
 2#define PAGES 336
 3#define WORDS 65618
 4int main()
 5{
 6    short num=PAGES;
 7    short mnum=-PAGES;
 8
 9    printf("bytes of short :%d\n",sizeof(short));
10    printf("bytes of int :%d\n",sizeof(int));
11    printf("bytes of char :%d\n",sizeof(char));
12    printf("num as short and unsigned short :%hd %hu\n",num,num);
13    printf("-num as short and unsigned short :%hd %hu\n",mnum,mnum);
14    printf("num as int and char :%d %c\n",num,num);
15    printf("WORDS as int,short and char :%d %hd %c\n",WORDS,WORDS,WORDS);
16
17    return 0;
18}

1bytes of short :2
2bytes of int :4
3bytes of char :1
4num as short and unsigned short :336 336
5-num as short and unsigned short :-336 65200
6num as int and char :336 P
7WORDS as int,short and char :65618 82 R

解释：
336
二进制原码：0000 0001 0101 0000 有符号数为336，无符号数为336
二进制补码：0000 0001 0101 0000 
-336
二进制原码：1000 0001 0101 0000 有符号数为-336，无符号数为65200
二进制补码：1111 1110 1011 0000
65618
二进制原码：0001 0000 0000 0101 0010  显示int时，取4个字节，为65618；显示短整型时，取后面2个字节，为80；显示字符类型时，取最后一个字节，
为82，即ASCII，字符为R。
注意，负数在在计算机中是用补码存放的。

当混淆了整数和浮点类型时，结果更是千奇百怪。
代码2：

 1#include<stdio.h>
 2int main()
 3{
 4    float n1=3.0;
 5    double n2=3.0;
 6    long n3=2000000000;
 7    long n4=1234567890;
 8
 9    printf("%.1e %.1e %.1e %.1e\n",n1,n2,n3,n4);
10    printf("%ld %ld\n",n3,n4);
11    printf("%ld %ld %ld %ld\n",n1,n2,n3,n4);
12
13    return 0;
14}

显示结果为：

13.0e+00 3.0e+00 3.1e+46 9.3e-305
22000000000 1234567890
30 1074266112 0 1074266112

解释：
计算机根据变量到类型而非转换说明符把这些值放到堆栈中。所以，n1在堆栈中占用8个字节(float转换为double)。同样，n2占用8个字节，而n3和n4则分别
占用4个字节。然后控制转移到printf()函数。该函数从堆栈把值读出来，但是在读取时，它根据转换说明符去读取。%ld说明符指出，printf()应该读取4个
字节，所以printf()在堆栈中读取前4个字节作为它到第一个值。这就是n1到前半部分，它被解释为一个长整数。下一个%ld说明符再读取4个字节，这就是n1的
后半部分。同样，%ld的第三个和第四个实例使得n2到前半部分和后半部分被读出，并被解释为两个长整数。所以，虽然n3和n4的说明符都正确，但是printf()
仍然读取了错误的字节。

10、返回值
printf()的返回值
返回打印的字符的数目，如果有输出错误，那么printf()会返回一个负数。
scanf()的返回值
返回成功读入的项目的个数。如果它没有读取任何项目（当它期望一个数字而您却键入一个非数字字符串时就会发生这种情况），scanf()会返回0.

11、使用scanf()该注意的地方：
从键盘输入的是文本，因为那些键生成文本字符：字母、数字和标点。比如说，当您想输入数字2004时，您键入字符2、0、0、4.如果想把它们存储成一个数值而
非字符串，那么您的程序必须把这个字符串逐个字符地转换成数值，这就是scanf()函数的工作。
printf()函数使用变量名、常量和表达式；而scanf()函数使用指向变量的指针。
scanf()函数使用空格(换行、制表符、空格)来决定怎样把输入分成几个字段。唯一到例外是%c说明，即使下一个字符是空白字符，它也会读取那个字符。

12、*在printf()和scanf()中的使用
在printf()函数中，假如不想事先指定字段宽度，而是希望由程序来指定该值，那么您可以在字段宽度部分用*代替数字来达到目的，但是你必须用一个参数告诉
函数字段宽度是什么。例如：

 1#include<stdio.h>
 2int main()
 3{
 4    int j=1;
 5    float i=2.3;
 6    int width,precision;
 7
 8    printf("width=");
 9    scanf("%d",&width);
10    printf("precision=");
11    scanf("%d",&precision);
12    printf("%*d\n",width,j);
13    printf("%*.*f\n",width,precision,i);
14
15    return 0;
16}

1width=8（手动输入8）
2precision=3 （手动输入3）
3       1
4   2.300

 1#include<stdio.h>
 2int main()
 3{
 4    int n;
 5    
 6    printf("Please enter three integers :\n");
 7    scanf("%*d %*d %d",&n);
 8    printf("The last integer was %d\n",n);
 9
10    return 0;
11}

12004 2005 2006 （手动输入三个数字）
2The last integer was 2006