黄色在线观看视频-黄色在线免费看-黄色在线视频免费-黄色在线视频免费看-免费啪啪网-免费啪啪网站

第二章  數據類型、變量和運算符

    本章首先介紹Turbo C程序的基本組成部分; 然后介紹Turbo C的數據類型、變
量類型、變量的初始化和賦值; 最后介紹Turbo C的有關操作。通過本節的學習,可
以對Turbo C語言有一個初步認識。

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

    Turbo C 2.0 象其它語言一樣按其規定的格式和提供的語句由用戶編寫應用程
序。 請看下面一段Turbo C源程序。 例1:
    /*Example program of Turbo C*/
    #include /*包含文件說明*/
    void lgc(void);/*子函數說明*/
    char answer;/*定義全程變量*/
    int main()/*主函數定義*/
    {
    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. 大多數語句結尾必須要用";"作為終止符,否則Turbo C 不認為該語句
結束;3. 每個程序必須有一個而且只能有一個稱作主函數的main()函數;4. 每個程
序體(主函數和每個子函數,如上例中的main()函數和sub()函數)必須用一對花括號"
{"和"}"括起來;5. 一個較完整的程序大致包括:包含文件(一組#include<*.h>語句)、
用戶函數說明部分、全程變量定義、主函數和若干子函數組成。在主函數和子函數
中又包括局部變量定義、 若干個Turbo C庫函數、控制流程語句、用戶函數的調用
語句等;6. 注釋部分包含在"/*"和"*/"之間,在編譯時它被Turbo C編譯器忽略。
    
    說明:1. 象其它一些語言一樣,Turbo C的變量在使用之前必須先定義其數據類
型,未經定義的變量不能使用。定義變量類型應在可執行語句前面,如上例main()函
數中的第一條語句就是變量定義語句,它必須放在第一各執行語句clrscr()前面。2.
在Turbo C中, 大、小寫字母是有區別的,相同字母的大、小寫代表不同的變量。3.
Turbo C程序的書寫格式非常靈活,沒有嚴格限制。

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

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


    2. 數據類型

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

    2.1 整型(int)

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

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

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

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

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

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

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

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

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

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


    3 關鍵字和標識符

    3.1  關鍵字
    所謂關鍵字就是已被Turbo C2.0本身使用, 不能作其它用途使用的字。例如關
鍵字不能用作變量名、函數名等。
    Turbo C2.0有以下關鍵字:
    Turbo C2.0擴展的共11個
     asm       _cs       _ds       _es       _ss       cdecl
     far       near      huge      interrupt pascal
    由ANSI標準定義的共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 標識符
    所謂標識符是指常量、變量、語句標號以及用戶自定義函數的名稱。 Turbo C
2.0標識符的定義十分靈活。作為標識符必須滿足以下規則:
    1. 所有標識符必須由一個字母(a~z, A~Z)或下劃線(_)開頭;
    2. 標識符的其它部分可以用字母、下劃線或數字(0~9)組成;
    3. 大小寫字母表示不同意義, 即代表不同的標識符;
    4. 標識符只有前32個字符有效;
    5. 標識符不能使用Turbo C2.0的關鍵字。
    下面舉出幾個正確和不正確的標識符:
               正確                不正確
               smart               5smart
               _decision           bomb?
               key_board           key.board
               FLOAT               float

    4. 變量

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

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

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

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

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

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

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

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

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

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

    4.5  變量的初始化和賦值

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

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

    3. 指針型變量的初始化
    例如:
     main()
     {
          int *i=7899;        /*定義整型數指針變量并初始化*/
          float *f=3.1415926; /*定義浮點數指針變量并初始化*/
          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;              /*將數字2(十進制ASCII值為50賦給a1*/
          a2='\x0d';          /*將回車符賦給a2*/
          .
          .
          .
     }

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

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

    (2)字符串數組的賦值
    例如:
      main()
     {
          char s[30];
          strcpy(s, "Good News!");  /*給數組賦字符串*/
          .
          .
          .
     }
    上面程序在編譯時, 遇到char s[30]這條語句時, 編譯程序會在內存的某處留
出連續30個字節的區域, 并將第一個字節的地址賦給s。當遇到strcpy( strcpy 為
Turbo C2.0的函數)時, 首先在目標文件的某處建立一個"Good News!\0" 的字符串。
其中\0表示字符串終止, 終止符是編譯時自動加上的, 然后一個字符一個字符地復
制到s所指的內存區域。因此定義字符串數組時,  其元素個數至少應該比字符串的
長度多1。
    注意:
    1. 字符串數組不能用"="直接賦值, 即s="Good News!"是不合法的。所以應分
清字符串數組和字符串指針的不同賦值方法。
    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)指針數組賦值
    例如:
     main()
     {
          char *f[2];
          int *a[2];
          f[0]="thank you";   /*給字符型數組指針變量賦值*/
          f[1]="Good Morning";
          *a[0]=1, *a[1]=-11; /*給整型數數組指針變量賦值*/
          .
          .
          .
     }

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


    5. 運算符

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

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

    一、一目和二目操作
    一目操作是指對一個操作數進行操作。例如: -a是對a進行一目負操作。
    二目操作(或多目操作)是指兩個操作數(或多個操作數)進行操作。
    在Turbo C中加、減、乘、除、取模的運算與其它高級語言相同。需要注意
的是除法和取模運算。
    例如:
      15/2    是15除以2商的整數部分7
      15%2    是15除以2的余數部分1
    對于取模運算符"%", 不能用于浮點數。
    另外, 由于Turbo C中字符型數會自動地轉換成整型數,  因此字符型數也可
以參加二目運算。
    例如:
     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運算符"++"和"--", 運算符"++"是操作數加1, 而"--" 則是
操作數減1。
    例如:
      x=x+1         可寫成x++, 或++x
      x=x-1         可寫成x--, 或--x
    x++(x--)與++x(--x)在上例中沒有什么區別, 但x=m++和x=++m卻有很大差別。
      x=m++    表示將m的值賦給x后, m加1。
      x=++m    表示m先加1后, 再將新值賦給x。

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

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

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

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

    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形式的語句。

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

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


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

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

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

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