第二章  數(shù)據(jù)類型、變量和運算符

    本章首先介紹Turbo C程序的基本組成部分; 然后介紹Turbo C的數(shù)據(jù)類型、變
量類型、變量的初始化和賦值; 最后介紹Turbo C的有關(guān)操作。通過本節(jié)的學(xué)習(xí),可
以對Turbo C語言有一個初步認(rèn)識。

    1. Turbo C程序的一般組成部分

    Turbo C 2.0 象其它語言一樣按其規(guī)定的格式和提供的語句由用戶編寫應(yīng)用程
序。 請看下面一段Turbo C源程序。 例1:
    /*Example program of Turbo C*/
    #include /*包含文件說明*/
    void lgc(void);/*子函數(shù)說明*/
    char answer;/*定義全程變量*/
    int main()/*主函數(shù)定義*/
    {
    char a;/*定義局部變量*/
    clrscr();
    gotoxy(12,3);
    puts("Welcome to use Turbo C2.0!");
    gotoxy(15,13);
    printf("--Exit");
    gotoxy(15,15);
    printf("--Continue");
    while(1)
    {
    a=getch();
    if(a==27)
    break;
    if(a==13)
    {
    lgc();
    if(answer=='y'||answer=='Y')
    {
    gotoxy(23,14);
    puts("Please Write to the Company");
    getch();
    break;
    }
    }
    }
    return(0);}void lgc(void){
    clrscr();
    gotoxy(12,8);
    printf("The Excellent Selection!");
    gotoxy(21,12);
    printf("Do you have any question?(Y/N)");
    answer=getche();}

    由例子程序可以看出,Turbo C源程序主要有以下幾個特點:1. 程序一般用小寫
字母書寫;2. 大多數(shù)語句結(jié)尾必須要用";"作為終止符,否則Turbo C 不認(rèn)為該語句
結(jié)束;3. 每個程序必須有一個而且只能有一個稱作主函數(shù)的main()函數(shù);4. 每個程
序體(主函數(shù)和每個子函數(shù),如上例中的main()函數(shù)和sub()函數(shù))必須用一對花括號"
{"和"}"括起來;5. 一個較完整的程序大致包括:包含文件(一組#include<*.h>語句)、
用戶函數(shù)說明部分、全程變量定義、主函數(shù)和若干子函數(shù)組成。在主函數(shù)和子函數(shù)
中又包括局部變量定義、 若干個Turbo C庫函數(shù)、控制流程語句、用戶函數(shù)的調(diào)用
語句等;6. 注釋部分包含在"/*"和"*/"之間,在編譯時它被Turbo C編譯器忽略。
    
    說明:1. 象其它一些語言一樣,Turbo C的變量在使用之前必須先定義其數(shù)據(jù)類
型,未經(jīng)定義的變量不能使用。定義變量類型應(yīng)在可執(zhí)行語句前面,如上例main()函
數(shù)中的第一條語句就是變量定義語句,它必須放在第一各執(zhí)行語句clrscr()前面。2.
在Turbo C中, 大、小寫字母是有區(qū)別的,相同字母的大、小寫代表不同的變量。3.
Turbo C程序的書寫格式非常靈活,沒有嚴(yán)格限制。

    例1的主函數(shù)可寫成:main(){char c;clrscr();gotoxy(12,3);
    puts("Welcome to use Turbo C2.0!");gotoxy(15,13);
    printf("--Continue");gotoxy(15,15);...}這樣寫語法上沒有錯誤,但閱
讀起來不方便, 同時也使得程序?qū)哟尾幻鞔_。作者建議用Turbo C編程時,一行一條
語句,遇到嵌套語句向后縮進,必要時對程序加上注釋行。這樣可以便程序結(jié)構(gòu)清楚、
易于閱讀、維護和修改。通過以上介紹,可以得出Turbo C源程序的一般形式為:
    包含文件
    子函數(shù)類型說明
    全程變量定義
    main()
    {
    局部變量定義
    <程序體>
    }
    sub1()
    {
    局部變量定義
    <程序體>
    }
    sub2()
    {
    局部變量定義
    <程序體>
    }
    .
    .
    .
    subN()
    {
    局部變量定義
    <程序體>
    }

    其中sub1() ,...,subN()代表用戶定義的子函數(shù),程序體指Turbo C 2.0提供的
任何庫函數(shù)調(diào)用語句、控制流程語句或其它用子函數(shù)調(diào)用語句等。


    2. 數(shù)據(jù)類型

    在Turbo C語言中, 每個變量在使用之前必須定義其數(shù)據(jù)類型。Turbo C有以下
幾種類型:整型(int)、浮點型(float)、字符型(char)、指針型(*)、無值型(void)
以及結(jié)構(gòu)(struct)和聯(lián)合(union)。其中前五種是Turbo C的基本數(shù)據(jù)類型、后兩種
數(shù)據(jù)類型(結(jié)構(gòu)和聯(lián)合)將在第五章介紹。

    2.1 整型(int)

    一、整型數(shù)說明
    加上不同的修飾符,整型數(shù)有以下幾種類型;
    signed short int 有符號短整型數(shù)說明。簡寫為short或int,字長為2
    字節(jié)共16位二進制數(shù),數(shù)的范圍是-32768~32767。
    signed long int 有符號長整型數(shù)說明。簡寫為long,字長為4字節(jié)共
    32位二進制數(shù),數(shù)的范圍是-2147483648~2147483647。
    unsigned short int 無符號短整型數(shù)說明。簡寫為unsigned int,字長
    為2字節(jié)共16位二進制數(shù),數(shù)的范圍是0~65535。
    unsigned long int 無符號長整型數(shù)說明。簡寫為unsigned long,字長
    為4字節(jié)共32位二進制數(shù),數(shù)的范圍是0~4294967295。

    二、整型變量定義
    可以用下列語句定義整型變量
    int a,b;/*a、b被定義為有符號短整型變量*/
    unsigned long c;/*c被定義為無符號長整型變量*/

    三、整型常數(shù)表示
    按不同的進制區(qū)分,整型常數(shù)有三種表示方法:
    十進制數(shù):以非0開始的數(shù)
    如:220,-560,45900
    八進制數(shù):以0開始的數(shù)
    如:06;0106,05788
    十六進制數(shù):以0X或0x開始的數(shù)
    如:0X0D,0XFF,0x4e
    另外,  可在整型常數(shù)后添加一個"L"或"l"字母表示該數(shù)為長整型數(shù),  如22L,
0773L,0Xae4l。

    2.2 浮點型(float)
    一、浮點數(shù)說明
    Turbo C中有以下兩種類型的浮點數(shù):
    float 單浮點數(shù)。字長為4 個字節(jié)共32 位二進制數(shù),數(shù)的范圍是
    3.4x10-38E~3.4x10+38E。
    double 雙浮點數(shù)。字長為 8個字節(jié)共 64 位二進制數(shù),數(shù)的范圍是
    1.7x10-308E~1.7x10+308E。
    說明:
    浮點數(shù)均為有符號浮點數(shù),沒有無符號浮點數(shù)。

    二、浮點型變量定義
    可以用下列語句定義浮點型變量:
    float a,f;/*a,f被定義為單浮點型變量*/
    double b;/*b被定義為雙浮點型變量*/

    三、浮點常數(shù)表示
    例如:+29.56,-56.33,-6.8e-18,6.365
    說明:
    1. 浮點常數(shù)只有一種進制(十進制)。
    2. 所有浮點常數(shù)都被默認(rèn)為double。
    3. 絕對值小于1的浮點數(shù), 其小數(shù)點前面的零可以省略。如:0.22可寫為.22,-
0.0015E-3可寫為-.0015E-3。
    4. Turbo C默認(rèn)格式輸出浮點數(shù)時,最多只保留小數(shù)點后六位。

    2.3 字符型(char)
    加上不同的修飾符,可以定義有符號和無符號兩種類型的字符型變量,例如:
    char a:/*a被定義為有符號字符變量*/
    unsigned char l;/*l被定義為無符號字符變量*/
    字符在計算機中以其ASCII碼方式表示,其長度為1個字節(jié),有符號字符型數(shù)取值
范圍為-128~127,無符號字符型數(shù)到值范圍是0~255。因此在Turbo C語言中,字符型
數(shù)據(jù)在操作時將按整型數(shù)處理,如果某個變量定義成char,則表明該變量是有符號的,
即它將轉(zhuǎn)換成有符號的整型數(shù)。
    Turbo C中規(guī)定對ASCII碼值大于0x80的字符將被認(rèn)為是負(fù)數(shù)。例如ASCII 值為
0x8c的字符,定義成char時,被轉(zhuǎn)換成十六進制的整數(shù)0xff8c 。這是因當(dāng)ASCII碼值
大于0x80時,該字節(jié)的最高位為1,計算機會認(rèn)為該數(shù)為負(fù)數(shù),對于0x8c表示的數(shù)實際
上是-74(8c的各位取反再加1) ,而-74 轉(zhuǎn)換成兩字節(jié)整型數(shù)并在計算機中表示時就
是0xff8c( 對0074 各位取反再加1) 。因此只有定義為unsigned char 0x8c轉(zhuǎn)換成
整型數(shù)時才是8c。這一點在處理大于0x80的ASCII碼字符時(例如漢字碼) 要特別注
意。一般漢字均定義為unsigned char(在以后的程序中會經(jīng)常碰到)。
    另外,也可以定義一個字符型數(shù)組(關(guān)于數(shù)組后面再作詳細介紹),此時該數(shù)組表
示一個字符串。
    例如:
    char str[10];
    計算機在編譯時, 將留出連續(xù)10個字符的空間,即str[0]到str[9]共10個變量,
但只有前9個供用戶使用。第10個str[9]用來存放字符串終止符NULL即"\0",但終止
符是編編譯程序自動加上的,這一點應(yīng)特別注意。

    二、字符常數(shù)表示
    能用符號表示的字符可直接用單引號括起來表示, 如'a','9','Z',也可用該字
符的ASCII碼值表示,例如十進制數(shù)85表示大寫字母'U',十六進制數(shù)0x5d表示']',八
進制數(shù)0102表示大寫字母'B'。
    一些不能用符號表示的控制符,只能用ASCII碼值來表示,如十進制數(shù)10 表示換
行,下六進制數(shù)0x0d表示回車,八進制數(shù)033表示Esc。Turbo C2.0中也有另外一種表
示表示方法,如'\033'表示Esc,這里'\ 0' 符號后面的數(shù)字表示十六進制的ASCII值
當(dāng)然這種表示方法也適用于可睦接用符號表示的字符。
    另外,Turbo C2.0中有些常用的字符用以下特殊規(guī)定來表示:
    規(guī)定符    等價于   含義
    '\f'      '\X0C'   換頁
    '\r'      '\X0D'   回車
    '\t'      '\X09'   制表鍵
    '\n'      '\X0A'   換行
    '\\'      '\X5C'   \符
    '\''      '\X27'   '符
    '\"'      '\X22'   "符
    對于字符串常量,一般用雙引號括起來表示,如"Hello Turbo C2.0"。

    2.4 指針型(*)
    指針是一種特殊的數(shù)據(jù)類型,在其它語言中一般沒有。指針是指向變量的地址,
實質(zhì)上指針就是存貯單元的地址。根據(jù)所指的變量類型不同,可以是整型指針(int*)、
浮點型指針(float *) 、字符型指針(char *) 、結(jié)構(gòu)指針(struct *) 和聯(lián)合指針
(union *)(結(jié)構(gòu)指針和聯(lián)合指針將在第4節(jié)中介紹)。

    2.5 無值型(void)
    無值型字節(jié)長度為0,主要有兩個用途:一是明確地表示一個函數(shù)不返回任何值;
一是產(chǎn)生一個同一類型指針(可根據(jù)需要動態(tài)分配給其內(nèi)存)。
    例如:
    void *buffer;/*buffer被定義為無值型指針*/


    3 關(guān)鍵字和標(biāo)識符

    3.1  關(guān)鍵字
    所謂關(guān)鍵字就是已被Turbo C2.0本身使用, 不能作其它用途使用的字。例如關(guān)
鍵字不能用作變量名、函數(shù)名等。
    Turbo C2.0有以下關(guān)鍵字:
    Turbo C2.0擴展的共11個
     asm       _cs       _ds       _es       _ss       cdecl
     far       near      huge      interrupt pascal
    由ANSI標(biāo)準(zhǔn)定義的共32個
     auto      double    int       struct    break     else
     long      switch    case      enum      register  typedef
     char      extern    return    union     const     float
     short     unsigned  continue  for       signed    void
     default   goto      sizeof    volatile  do        if
     while     static

    3.2 標(biāo)識符
    所謂標(biāo)識符是指常量、變量、語句標(biāo)號以及用戶自定義函數(shù)的名稱。 Turbo C
2.0標(biāo)識符的定義十分靈活。作為標(biāo)識符必須滿足以下規(guī)則:
    1. 所有標(biāo)識符必須由一個字母(a~z, A~Z)或下劃線(_)開頭;
    2. 標(biāo)識符的其它部分可以用字母、下劃線或數(shù)字(0~9)組成;
    3. 大小寫字母表示不同意義, 即代表不同的標(biāo)識符;
    4. 標(biāo)識符只有前32個字符有效;
    5. 標(biāo)識符不能使用Turbo C2.0的關(guān)鍵字。
    下面舉出幾個正確和不正確的標(biāo)識符:
               正確                不正確
               smart               5smart
               _decision           bomb?
               key_board           key.board
               FLOAT               float

    4. 變量

    4.1  變量說明
    Turbo C2.0規(guī)定所有變量在使用前都必須中以說明。一條變量說明語句由數(shù)據(jù)
類型和其后的一個或多個變量名組成。變量說明的形式如下:
    類型 <變量表>;
    這里類型是指Turbo C2.0的有效數(shù)據(jù)類型。變量表是一個或多個標(biāo)識符名, 每
個標(biāo)識符之間用","分隔。
    例如:
          int i, j, k;   unsigned char c, str[5], *p;

    4.2 變量種類
    變量可以在程序中三個地方說明: 函數(shù)內(nèi)部、函數(shù)的參數(shù)定義中或所有的函數(shù)
外部。根據(jù)所定義位置的不同, 變量可分為局部變量、形式參數(shù)和全程變量。
    一、局部變量
    局部變量是指在函數(shù)內(nèi)部說明的變量(有時也稱為自動變量)。用關(guān)鍵字auto進
行說明, 當(dāng)auto省略時, 所有的非全程變量都被認(rèn)為是局部變量, 所以auto實際上
從來不用。
    局部變量在函數(shù)調(diào)用時自動產(chǎn)生, 但不會自動初始化, 隨函數(shù)調(diào)用的結(jié)束, 這
個變量也就自動消失了, 下次調(diào)用此函數(shù)時再自動產(chǎn)生, 還要再賦值, 退出時又自
動消失。

    二、形式參數(shù)
    形式參數(shù)是指在函數(shù)名后面的小括號里定義的變量, 用于接受來自調(diào)用函數(shù)的
參數(shù)。形式參數(shù)在函數(shù)內(nèi)部可以象其它局部變量那樣來作用。
    例如:
     puthz(int x, int y, int color, char *p)
     {
          int i, j, k;   /*定義局部變量*/
          <程序體>
     }
    其中x, y, color, *p為函數(shù)的形式參數(shù),  不需要再進行說明就可在該函數(shù)內(nèi)
直使用。

    三、全程變量
    全程變量是指在所有函數(shù)之外說明的變量, 它在整個程序內(nèi)部者是"可見的",
可以被任何一個函數(shù)使用, 并且在整個程序的運行中都保留其值。全程變量只要滿
足在使用它以前和函數(shù)以外這兩個條件, 可在程序的任何位置進行說明, 習(xí)慣上通
常在程序的主函數(shù)前說明。
    例如:
     #include
     int test;                /*定義全程變量*/
     void f1(int x, float y); /*子函數(shù)說明*/
     void f2(void);           /*子函數(shù)說明*/
     main()
     {
          test=5;             /*給全程變量賦值*/
          f1(20, 5.5);        /*調(diào)用有形式參數(shù)的子函數(shù)f1()*/
                              /*test的值變成115*/
          f2();               /*調(diào)用f2(), test的值變?yōu)?150*/
     }
     void f1(int x, float y)
     {
          float z;            /*z定義為局部變量*/
          z=x*y;              /*計算*/
          test=test+z;
     }
     void f2(void)
     {
          int count=10;       /*定義局部變量并初始化*/
          test=test*count;
     }

    由于全程變量可被整個程序內(nèi)的任何一個函數(shù)使用, 所以可作為函數(shù)之間傳遞
參數(shù)的手段, 但全程變量太多時, 內(nèi)存開銷變大。
    4.3 變量存儲類型
    Turbo C2.0支持四種變量存儲類型。說明符如下:
     auto      static    extern    register
下面分別來介紹。
    一、auto
    auto稱為自動變量, 已在前面作了介紹, 這里不再重復(fù)。
    二、static
    static稱為靜態(tài)變量。根據(jù)變量的類型可以分為靜態(tài)局部變量和靜態(tài)全程變量。
    1. 靜態(tài)局部變量
    它與局部變量的區(qū)別在于: 在函數(shù)退出時, 這個變量始終存在, 但不能被其它
函數(shù)使用, 當(dāng)再次進入該函數(shù)時, 將保存上次的結(jié)果。其它與局部變量一樣。
    2. 靜態(tài)全程變量
    Turbo C2.0允許將大型程序分成若干獨立模塊文件分別編譯, 然后將所有模塊
的目標(biāo)文件連接在一起, 從而提高編譯速度, 同時也便于軟件的管理和維護。靜態(tài)
全程變量就是指只在定義它的源文件中可見而在其它源文件中不可見的變量。它與
全程變量的區(qū)別是: 全程變量可以再說明為外部變量(extern), 被其它源文件使用,
而靜態(tài)全程變量卻不能再被說明為外部的, 即只能被所在的源文件使用。
    三、extern
    extern稱為外部變量。為了使變量除了在定義它的源文件中可以使用外, 還要
被其它文件使用。因此,   必須將全程變量通知每一個程序模塊文件,   此時可用
extern來說明。
    例如:
        文件1為file1.c                  文件2為file2.c
    int i, j;/*定義全程變量*/        extern int i, j;/*說明將i, j從
                                                     文件1中復(fù)制過來*/
    char c;                          extern char c; /*將c復(fù)制過來*/
    void func1(int k);               func2()        /*用戶定義函數(shù)*/
                                     {
    main()                              static float k;/*定義靜態(tài)變量*/
    {                                   i=j*5/100;
          func1(20);/*調(diào)用函數(shù)*/        k=i/1.5;
          func2();                           .
          .                                  .
          .                                  .
          .                            }
     }
     func1(int k) /*用戶定義函數(shù)*/
     {
          j=k*100;
     }

    對于以上兩個文件file1.c和file2.c, 用Turbo C2.0的集成開發(fā)環(huán)境進行編譯
連接時, 首先應(yīng)建立一個.prj的文件。例如file.prj, 該文件內(nèi)容如下:
     file1.c
     file2.c
    然后將file.prj的文件名寫入主菜單Project中的Project Name項中。 再用F9
編譯連接, 就可產(chǎn)生一個文件名為fioe.exe的可執(zhí)行文件。
    外部變量和FORTRAN語言中的COMMOM定義的公共變量一樣。
    四、register
    register稱為寄存器變量。它只能用于整型和字符型變量。定義符register說
明的變量被Turbo C2.0存儲在CPU的寄存器中,  而不是象普通的變量那樣存儲在內(nèi)
存中, 這樣可以提高運算速度。但是Turbo C2.0只允許同時定義兩個寄存器變量,
一旦超過兩個, 編譯程序會自動地將超過限制數(shù)目的寄存器變量當(dāng)作非寄存器變量
來處理。因此, 寄存器變量常用在同一變量名頻繁出現(xiàn)的地方。
    另外, 寄存器變量只適用于局部變量和函數(shù)的形式參數(shù), 它屬于auto型變量,
因此, 不能用作全程變量。定義一個整型寄存器變量可寫成:
      register int a;
    對于以上所介紹的變量類型和變量存儲類型將會在以后的學(xué)習(xí)中, 通過例行程
序中的定義、使用來逐漸加深理解。

    4.4  數(shù)組變量
    所謂數(shù)組就是指具有相同數(shù)據(jù)類型的變量集, 并擁有共同的名字。數(shù)組中的每
個特定元素都使用下標(biāo)來訪問。數(shù)組由一段連續(xù)的存貯地址構(gòu)成, 最低的地址對應(yīng)
于第一個數(shù)組元素, 最高的地址對應(yīng)最后一個數(shù)組元素。數(shù)組可以是一維的、也可
以是多維的。Turbo C2.0象它高級語方一樣也使用數(shù)組變量。

    一、一維數(shù)組
    一維數(shù)組的說明格式是:
      類型  變量名[長度];
    類型是指數(shù)據(jù)類型, 即每一個數(shù)組元素的數(shù)據(jù)類型, 包括整數(shù)型、浮點型、字
符型、指針型以及結(jié)構(gòu)和聯(lián)合。
    例如:
     int a[10];
     unsigned long a[20];
     char *s[5];
     char *f[];

    說明:
    1. 數(shù)組都是以0作為第一個元素的下標(biāo), 因此, 當(dāng)說明一個int a[16] 的整型
數(shù)組時, 表明該數(shù)組有16個元素, a[0]~a[15], 一個元素為一個整型變量。
    2. 大多數(shù)字符串用一維數(shù)組表示。數(shù)組元素的多少表示字符串長度,  數(shù)組名
表示字符串中第一個字符的地址,   例如在語句char  str[ 8] 說明的數(shù)組中存入
"hello"字符串后, str表示第一個字母"h"所在的內(nèi)存單元地址。str[0] 存放的是
字母"h"的ASCII碼值, 以此類推, str[4]存入的是字母"o"的ASCII碼值, str[5]則
應(yīng)存放字符串終止符'\0'。
    3. Turbo C2.0對數(shù)組不作邊界檢查。例如用下面語句說明兩個數(shù)組
    char str1[5], str2[6];
    當(dāng)賦給str1一個字符串"ABCDEFG"時, 只有"ABCDE"被賦給, "E" 將會自動的賦
給str2, 這點應(yīng)特別注意。

    三、多維數(shù)組
    多維數(shù)組的一般說明格式是:
       類型  數(shù)組名[第n維長度][第n-1維長度]......[第1維長度];
    這種說明方式與BASIC、FORTRAN等語言中多維數(shù)組的說明不一樣。
    例如:
      int m[3][2];       /*定義一個整數(shù)型的二維數(shù)組*/
      char c[2][2][3];   /*定義一個字符型的三維數(shù)組*/
    數(shù)組m[3][2]共有3*2=6個元素, 順序為:
      m[0][0], m[0][1], m[1][0], m[1][1], m[2][0], m[2][1];
    數(shù)組c[2][2][3]共有2*2*3=12個元素, 順序為:
      c[0][0][0], c[0][0][1], c[0][0][2],
      c[0][1][0], c[0][1][1], c[0][1][2],
      c[1][0][0], c[1][0][1], c[1][0][2],
      c[1][1][0], c[1][1][1], c[1][1][2],
    數(shù)組占用的內(nèi)存空間(即字節(jié)數(shù))的計算式為:
     字節(jié)數(shù)=第1維長度*第2維長度*...*第n維長度*該數(shù)組數(shù)據(jù)類型占用的字節(jié)數(shù)

    4.5  變量的初始化和賦值

    一、變量的初始化
    變量的初始化是指變量在被說明的同時賦給一個初值。Turbo C2.0中外部變量
和靜態(tài)全程變量在程序開始處被初始化, 局部變量包括靜態(tài)局部變量是在進入定義
它們的函數(shù)或復(fù)合語句時才作初始化。所有全程變量在沒有明確的初始化時將被自
動清零, 而局部變量和寄存器變量在未賦值前其值是不確定的。
    對于外部變量和靜態(tài)變量, 初值必須是常數(shù)表達式, 而自動變量和寄存器變量
可以是任意的表達式, 這個表達式可以包括常數(shù)和前面說明過的變量和函數(shù)。
    1. 單個變量的初始化
    例如:
     float f0, f1=0.2;/*定義全程變量, 在初始化時f0被清零, f1被賦0.2*/
     main()
     {
          static int i=10, j; /*定義靜態(tài)局部變量, 初始化時i被賦10, j不確
                              定*/
          int k=i*5;          /*定義局部變量, 初始化時k被賦10*5=50*/
          char c='y';         /*定義字符型指什變量并初始化*/
          .
          .
          .
     }

    2. 數(shù)組變量的初始化
    例如:
     main()
     {
          int p[2][3]={{2, -9, 0}, {8, 2, -5}};  /*定義數(shù)組p并初始化/*
          int m[2][4]={{27, -5, 19, 3}, {1, 8, -14, -2}};/*定義數(shù)組m并初
                                                         始化*/
          char *f[]={'A', 'B', 'C'};         /*定義數(shù)組f并初始化*/
          .
          .
          .
     }
    從上例可以看出: Turbo C2.0中數(shù)組進行初始化有下述規(guī)則:
    (1) 數(shù)組的每一行初始化賦值用"{}"并用","分開, 總的再加一對"{}"括起來,
最后以";"表示結(jié)束。
    (2) 多維數(shù)組的存儲是按最右維數(shù)的變量變化最快的原則。
    (3) 多維數(shù)組存儲是連續(xù)的, 因此可以用一維數(shù)組初始化的辦法來初始化多維
數(shù)組。
    例如:
     int x[2][3]={1, 2, 3, 4, 5, 6};/*用一維數(shù)組來初始化二維數(shù)組*/
    (4) 對數(shù)組初始化時, 如果初值表中的數(shù)據(jù)個數(shù)比數(shù)組元素少, 則不足的數(shù)組
元素用0來填補。
    (5) 對指針型變量數(shù)組可以不規(guī)定維數(shù), 在初始化賦值時, 數(shù)組維數(shù)從0 開始
被連續(xù)賦值。
    例如:
     char *f[]={'a', 'b', 'c'};
    初始化時將會給3個字符指針賦值, 即: *f[0]='a', *f[1]='b', *f[2]='c'。

    3. 指針型變量的初始化
    例如:
     main()
     {
          int *i=7899;        /*定義整型數(shù)指針變量并初始化*/
          float *f=3.1415926; /*定義浮點數(shù)指針變量并初始化*/
          char *s="Good";     /*定義字符型指針變量并初始化*/
          .
          .
          .
     }

    二、變量的賦值
    變量賦值是給已說明的變量賦給一個特定值。
    1. 單個變量的賦值
    (1) 整型變量和浮點變量
    這兩種變量采用下列格式賦值
          變量名=表達式;
    例如:
     main()
     {
          int a, m;      /*定義局部整型變量a, m*/
          float n;       /*定義局部浮點變量f*/
          a=100, m=20;   /*給變量賦值*/
          n=a*m*0.1;
          .
          .
          .
     }

    說明:
    Turbo C2.0中允許給多個變量賦同一值時可用連等的方式。
    例如:
     main()
     {
          int a, b, c;
          a=b=c=0;       /*同時給a,b,c賦值*/
          .
          .
          .
     }

    (2)  字符型變量
    字符型變量可以用三種方法賦值。
    例如:
     main()
     {
          char a0, a1, a2;    /*定義局部字符型變量a0, a1, a2*/
          a0='b';             /*將字母b賦給a0*/
          a1=50;              /*將數(shù)字2(十進制ASCII值為50賦給a1*/
          a2='\x0d';          /*將回車符賦給a2*/
          .
          .
          .
     }

    (3) 指針型變量
    例如:
     main()
     {
          int *i;
          char *str;
          *i=100;
          str="Good";
          .
          .
          .
     }
    *i表示i是一個指向整型數(shù)的指針, 即*i是一個整型變量, i是一個指向該整型
變量的地址。
    *str表示str是一個字符型指針, 即保留某個字符地址。在初始化時, str沒有
什么特殊的值, 而在執(zhí)行str="Good"時, 編譯器先在目標(biāo)文件的某處保留一個空間
存放"Good\0"的字符串, 然后把這個字符串的第一個字母"G"的地址賦給str, 其中
字符串結(jié)尾符"\0"是編譯程序自動加上的。
    對于指針變量的使用要特別注意。上例中兩個指針在說明前沒有初始化, 因此
這兩指針為隨機地址, 在小存儲模式下使用將會有破壞機器的危險。正確的使用辦
法如下:
    例如:
     main()
     {
          int *i;
          char *str;
          i=(int*)malloc(sizeof(int));
          i=420;
          str=(char*)malloc(20);
          str="Good, Answer!";
          .
          .
          .
     }
    上例中, 函數(shù)(int*)malloc(sizeof(int))表示分配連續(xù)的sizeof(int)=2個字
節(jié)的整型數(shù)存儲空間并返回其首地址。同樣(char*)malloc(20)表示分配連續(xù)20 個
字節(jié)的字符存儲空間并返回首地址(有關(guān)該函數(shù)以后再詳述)。由動態(tài)內(nèi)存分配函數(shù)
malloc()分配了內(nèi)存空間后, 這部分內(nèi)存將專供指針變量使用。
    如果要使i指向三個整型數(shù), 則用下述方法。
    例如:
     #include
     main()
     {
          int *a;
          a=(int*)malloc(3*sizeof(int));
          *a=1234;
          *(a+1)=4567;
          *(a+2)=234;
          .
          .
          .
     }
    *i=1234表示把1234存放到i指向的地址中去, 但對于*(i+1)=4567,  如果認(rèn)為
將4567存放到i指向的下一個字節(jié)中就錯了。Turbo C2.0中只要說明i為整型指針,
則    (i+1)  等價于   i+1*sizeof(int)
同樣  (i+2)  等價于   i+2*sizeof(int)

    2. 數(shù)組變量的賦值
    (1) 整型數(shù)組和浮點數(shù)組的賦值
    例如:
     main()
     {
          int m[2][2];
          float n[3];
          m[0][0]=0, m[0][1]=17, m[1][0]=21;/*數(shù)組元素賦值*/
          n[0]=109.5, n[1]=-8.29, n[2]=0.7;
          .
          .
          .
     }

    (2)字符串?dāng)?shù)組的賦值
    例如:
      main()
     {
          char s[30];
          strcpy(s, "Good News!");  /*給數(shù)組賦字符串*/
          .
          .
          .
     }
    上面程序在編譯時, 遇到char s[30]這條語句時, 編譯程序會在內(nèi)存的某處留
出連續(xù)30個字節(jié)的區(qū)域, 并將第一個字節(jié)的地址賦給s。當(dāng)遇到strcpy( strcpy 為
Turbo C2.0的函數(shù))時, 首先在目標(biāo)文件的某處建立一個"Good News!\0" 的字符串。
其中\(zhòng)0表示字符串終止, 終止符是編譯時自動加上的, 然后一個字符一個字符地復(fù)
制到s所指的內(nèi)存區(qū)域。因此定義字符串?dāng)?shù)組時,  其元素個數(shù)至少應(yīng)該比字符串的
長度多1。
    注意:
    1. 字符串?dāng)?shù)組不能用"="直接賦值, 即s="Good News!"是不合法的。所以應(yīng)分
清字符串?dāng)?shù)組和字符串指針的不同賦值方法。
    2. 對于長字符串, Turbo C2.0允許使用下述方法:
    例如:
     main()
     {
          char s[100];
          strcpy(s, "The writer would like to thank you for"
                    "your interest in his book. He hopes you"
                    "can get some helps from the book.");
          .
          .
          .
     }

    (3)指針數(shù)組賦值
    例如:
     main()
     {
          char *f[2];
          int *a[2];
          f[0]="thank you";   /*給字符型數(shù)組指針變量賦值*/
          f[1]="Good Morning";
          *a[0]=1, *a[1]=-11; /*給整型數(shù)數(shù)組指針變量賦值*/
          .
          .
          .
     }

    三、數(shù)組與指針
    數(shù)組與指針有密切的聯(lián)系。數(shù)組名本身就是該數(shù)組的指針, 反過來, 也可以把
指針看成一個數(shù)組, 數(shù)組名和指針實質(zhì)上都是地址, 但是指針是變量, 可以作運算。
而數(shù)組名是常量, 不能進行運算。
    例如:
     main()
     {
          char s[30], *p; /*定義字符型數(shù)組和指針變量*/
          p=s;            /*指針p指向數(shù)組s的第一個元素s[0]的地址*/
          .
          .
          .
          *(p+8);         /*指針p指向數(shù)組s的第9個元素s[8]的地址*/
          .
          .
          .
     }
    由上例可以看出數(shù)組和指針有如下關(guān)系:
    (p+i)=&(s[i])
    *(p+i)=s[i]
    因此, 利用上述表達式可以對數(shù)組和指針進行互換。兩者的區(qū)別僅在于: 數(shù)組
s是程序自動為它分配了所需的存儲空間; 而指針p則是利用動態(tài)分想函數(shù)為它分配
存儲空間或賦給它一個已分配的空間地址。


    5. 運算符

    Turbo C的運算符非常豐富, 主要分為三大類: 算術(shù)運算符,  關(guān)系運算符與
邏輯運算符, 按位運算符。除此之外, 還有一些用于完成特殊任務(wù)的運算符。下
面分別進行介紹。

    5.1 算術(shù)運算符
    Turbo C的算術(shù)運算符如下:
━━━━━━━━━━━━━━━━━━━━━━━━━━━━
       操作符                          作用
────────────────────────────
          +                        加, 一目取正
          -                        減, 一目取負(fù)
          *                             乘
          /                             除
          %                            取模
          --                            減1
          ++                            加1
━━━━━━━━━━━━━━━━━━━━━━━━━━━━

    一、一目和二目操作
    一目操作是指對一個操作數(shù)進行操作。例如: -a是對a進行一目負(fù)操作。
    二目操作(或多目操作)是指兩個操作數(shù)(或多個操作數(shù))進行操作。
    在Turbo C中加、減、乘、除、取模的運算與其它高級語言相同。需要注意
的是除法和取模運算。
    例如:
      15/2    是15除以2商的整數(shù)部分7
      15%2    是15除以2的余數(shù)部分1
    對于取模運算符"%", 不能用于浮點數(shù)。
    另外, 由于Turbo C中字符型數(shù)會自動地轉(zhuǎn)換成整型數(shù),  因此字符型數(shù)也可
以參加二目運算。
    例如:
     main()
     {
          char m, n;     /*定義字符型變量*/
          m='c';         /*給m賦小寫字母'c'*/
          n=m+'A'-'a';   /*將c中的小寫字母變成大寫字母'B'后賦給n*/
          ...
     }
    上例中m='c'即m=98, 由于字母A和a的ASCII碼值分別為65和97。這樣可以將
小寫字母變成大寫字母, 反之, 如果要將大寫字母變成小寫字母,  則用c+ 'a'
-'A'進行計算。

    二、增量運算
    在Turbo C中有兩個很有用的運算符, 在其它高級語言中通常沒有。這兩個
運算符就是增1和減1運算符"++"和"--", 運算符"++"是操作數(shù)加1, 而"--" 則是
操作數(shù)減1。
    例如:
      x=x+1         可寫成x++, 或++x
      x=x-1         可寫成x--, 或--x
    x++(x--)與++x(--x)在上例中沒有什么區(qū)別, 但x=m++和x=++m卻有很大差別。
      x=m++    表示將m的值賦給x后, m加1。
      x=++m    表示m先加1后, 再將新值賦給x。

    三、賦值語句中的數(shù)據(jù)類型轉(zhuǎn)換
    類型轉(zhuǎn)換是指不同類型的變量混用時的類型改變。
    在賦值語句中, 類型轉(zhuǎn)換規(guī)則是:
      等號右邊的值轉(zhuǎn)換為等號左邊變量所屬的類型。
    例如:
     main()
     {
          int i, j;      /*定義整型變量*/
          float f, g=2.58;    /*定義浮點型變量*/
          f=i*j;         /*i與j的乘積是整型數(shù), 被轉(zhuǎn)換成為浮點數(shù)賦給f*/
          i=g;           /*g中的浮點型數(shù)轉(zhuǎn)換成為整型數(shù)賦給i*/
          ...
     }
    由于Turbo C按上述數(shù)據(jù)類型轉(zhuǎn)換規(guī)則, 因此在作除法運算時應(yīng)特別注意。
    例如:
     main()
     {
          float f;
          int i=15;
          f=i/2;
     }
    上面程序經(jīng)運行后, f=7并不等于準(zhǔn)確值7.5。正確的程序應(yīng)該是:
     main()
     {
          float f;
          int i=15;
          f=i/2.0;
     }
    也可直接將i定義為浮點數(shù)。

    5.2 關(guān)系運算符和邏輯運算符
    一、邏輯運算符
    邏輯運算符是指用形式邏輯原則來建立數(shù)值間關(guān)系的符號。
    Turbo C的邏輯運算符如下:
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
        操作符                      作用
─────────────────────────────
          &&                       邏輯與
          ||                       邏輯或
          !                        邏輯非
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━

    二、關(guān)系運算符
    關(guān)系運算符是比較兩個操作數(shù)大小的符號。
    Turbo C的關(guān)系運算符如下:
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
        操作符                        作用
─────────────────────────────
          >                           大于
          >=                        大于等于
          <                           小于
          <=                        小于等于
          ==                          等于
          !=                         不等于
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
    關(guān)系運算符和邏輯運算符的關(guān)鍵是真(true)和假(false)的概念。Turbo C中
true可以是不為0的任何值, 而false則為0。 使用關(guān)系運算符和邏輯運算符表達
式時, 若表達式為真(即true)則返回1, 否則, 表達式為假(即false),  則返回0。
    例如:
     100>99         返回1
     10>(2+10)      返回0
     !1&&0          返加0
    對上例中表達式!1&&0, 先求!1和先求1&&0將會等于出不同的結(jié)果,  那么何
者優(yōu)先呢? 這在Turbo C中是有規(guī)定的。 有關(guān)運算符的優(yōu)先級本節(jié)后面將會講到。

    5.3 按位運算符
    Turbo C和其它高級語言不同的是它完全支持按位運算符。這與匯編語言的
位操作有些相似。
    Turbo C中按位運算符有:
━━━━━━━━━━━━━━━━━━━━━━━━━━━━
        操作符                       作用
────────────────────────────
          &                        位邏輯與
          |                        位邏輯或
          ^                       位邏輯異或
          -                        位邏輯反
          >>                         右移
          <<                         左移
━━━━━━━━━━━━━━━━━━━━━━━━━━━━
    按位運算是對字節(jié)或字中的實際位進行檢測、設(shè)置或移位, 它只適用于字符
型和整數(shù)型變量以及它們的變體, 對其它數(shù)據(jù)類型不適用。
    關(guān)系運算和邏輯運算表達式的結(jié)果只能是1或0。 而按位運算的結(jié)果可以取0
或1以外的值。
    要注意區(qū)別按位運算符和邏輯運算符的不同, 例如, 若x=7, 則x&&8 的值為
真(兩個非零值相與仍為非零), 而x&8的值為0。
    移位運算符">>"和"<<"是指將變量中的每一位向右或向左移動, 其通常形式
為:
     右移:     變量名>>移位的位數(shù)
     左移:     變量名<<移位的位數(shù)
    經(jīng)過移位后, 一端的位被"擠掉",   而另一端空出的位以0 填補,   所以,
Turbo C中的移位不是循環(huán)移動的。

    5.4 Turbo C的特殊運算符
    一、"?"運算符
    "?"運算符是一個三目運算符, 其一般形式是:
      <表達式1>?<表達式2>:<表達式3>;
    "?"運算符的含義是: 先求表達式1的值, 如果為真, 則求表達式2 的值并把
它作為整個表達式的值; 如果表達式1 的值為假, 則求表達式3 的值并把它作為
整個表達式的值。
    例如:
     main()
     {
          int x, y;
          x=50;
          y=x>70?100:0;
     }
    本例中, y將被賦值0。如果x=80, y將被賦值100。
    因此, "?"運算符可以代替某些if-then-else形式的語句。

    二、"&"和"*"運算符
    "&"運算符是一個返回操作數(shù)地址的單目操作符。
    "*"運算符是對"&"運算符的一個補充, 它返回位于這個地址內(nèi)的變量值, 也
是單目操作符。
    例如:
     main()
     {
          int i, j, *m;
          i=10;
          m=&i;          /*將變量i的地址賦給m*/
          j=*m;          /*地址m所指的單元的值賦給j*/
     }
    上面程序運行后, i=10, m為其對應(yīng)的內(nèi)存地址, j的值也為10。

    三、","運算符
    ","運算符用于將多個表達式串在一起, ","運算符的左邊總不返回, 右邊表
達式的值才是整個表達式的值。
    例如:
     main()
     {
          int x, y;
          x=50;
          y=(x=x-5, x/5);
     }
    上面程序執(zhí)行后y值為9, 因為x的初始值為50, 減5后變?yōu)?5, 45除5為9賦給
y。


    四、sizeof運算符
    sizeof運算符是一個單目運算符, 它返回變量或類型的字節(jié)長度。
    例如:
     sizeof(double) 為8
     sizeof(int)    為2
    也可以求已定義的變量, 例如:
     float f;
     int i;
     i=sizeof(f);
    則i的值將為4。

    五、聯(lián)合操作
    Turbo C中有一特殊的簡寫方式, 它用來簡化一種賦值語句,  適用于所有的
雙目運算符。其一般形式為:
     <變量>=<變量><操作數(shù)><表達式>
    相當(dāng)于
     <變量><操作數(shù)>=<表達式>
    例如:
      a=a+b         可寫成    a+=b
      a=a&b         可寫成    a&=b
      a=a/(b-c)     可寫成    a/=b-c

   5.5 Turbo C運算符的優(yōu)先級
    Turbo C規(guī)定了運算符的優(yōu)先次序即優(yōu)先級。 當(dāng)一個表達式中有多個運算符
參加運算時, 將按下表所規(guī)定的優(yōu)先級進行運算。表中優(yōu)先級從上往下逐漸降低,
同一行優(yōu)先級相同。
    例如:
       表達式 10>4&&!(100<99)||3<=5 的值為1
       表達式 10>4&&!(100<99)&&3<=5 的值為0

               Turbo C運算符的優(yōu)先次序
━━━━━━━━━━━━━━━━━━━━━━━━━━━━┳━━━━
                    表達式                              ┃優(yōu)先級
────────────────────────────╂────
  ()(小括號) [](數(shù)組下標(biāo)) .(結(jié)構(gòu)成員) ->(指針型結(jié)構(gòu)成員)┃ 最高
────────────────────────────┃  ↑
!(邏輯非) .(位取反) -(負(fù)號) ++(加1) --(減1) &(變量地址)┃  │
────────────────────────────┃  │
   *(指針?biāo)�指�?nèi)容)  type(函數(shù)說明)  sizeof(長度計算)    ┃  │
────────────────────────────┃  │
     *(乘)     /(除)     %(取模)                        ┃  │
────────────────────────────┃  │
     +(加)     -(減)                                    ┃  │
────────────────────────────┃  │
     <<(位左移)          >>(位右移)                     ┃  │
────────────────────────────┃  │
     <(小于)   <=(小于等于)   >(大于)   >=(大于等于)    ┃  │
────────────────────────────┃  │
     ==(等于)       !=(不等于)                          ┃  │
────────────────────────────┃  │
     &(位與)                                            ┃  │
────────────────────────────┃  │
     ^(位異或)                                          ┃  │
────────────────────────────┃  │
     |(位或)                                            ┃  │
────────────────────────────┃  │
     &&(邏輯與)                                         ┃  │
────────────────────────────┃  │
     ||(邏輯或)                                         ┃  │
────────────────────────────┃  │
     ?:(?表達式)                                        ┃  │
────────────────────────────┃  │
     =    +=   -=(聯(lián)合操作)                             ┃  │
────────────────────────────┃  │
     ,(逗號運算符)                                      ┃ 最低