一、指针函数
    当一个函数声明其返回值为一个指针时，实际上就是返回一个地址给调用函数，以用于需要指针或地址的表达式中。
    格式：
         类型说明符 * 函数名(参数)
    当然了，由于返回的是一个地址，所以类型说明符一般都是int。
    例如：int *GetDate();
          int * aaa(int,int);
    函数返回的是一个地址值，经常使用在返回数组的某一元素地址上。
        int * GetDate(int wk,int dy);
        main()
        {
            int wk,dy;
            do
            {
                printf(Enter week(1-5)day(1-7)\n);
                scanf(%d%d,&wk,&dy);
            }
            while(wk<1||wk>5||dy<1||dy>7);
            printf(%d\n,*GetDate(wk,dy));
        }
        int * GetDate(int wk,int dy)
        {
            static int calendar[5][7]=
            {
               {1,2,3,4,5,6,7},
               {8,9,10,11,12,13,14},
               {15,16,17,18,19,20,21},
               {22,23,24,25,26,27,28},
               {29,30,31,-1}
            };
            return &calendar[wk-1][dy-1];
        }
        程序应该是很好理解的，子函数返回的是数组某元素的地址。输出的是这个地址里的值。
二、函数指针
    指向函数的指针包含了函数的地址，可以通过它来调用函数。声明格式如下：
        类型说明符 (*函数名)(参数)
    其实这里不能称为函数名，应该叫做指针的变量名。这个特殊的指针指向一个返回整型值的函数。指针的声明笔削和它指向函数的声明保持一致。
        指针名和指针运算符外面的括号改变了默认的运算符优先级。如果没有圆括号，就变成了一个返回整型指针的函数的原型声明。
    例如：
        void (*fptr)();
    把函数的地址赋值给函数指针，可以采用下面两种形式：
        fptr=&Function;
        fptr=Function;
    取地址运算符&不是必需的，因为单单一个函数标识符就标号表示了它的地址，如果是函数调用，还必须包含一个圆括号括起来的参数表。
    可以采用如下两种方式来通过指针调用函数：
        x=(*fptr)();
        x=fptr();
    第二种格式看上去和函数调用无异。但是有些程序员倾向于使用第一种格式，因为它明确指出是通过指针而非函数名来调用函数的。下面举一个例子：
        void (*funcp)();
        void FileFunc(),EditFunc();
        main()
        {
            funcp=FileFunc;
            (*funcp)();
            funcp=EditFunc;
            (*funcp)();
        }
        void FileFunc()
        {
            printf(FileFunc\n);
        }
        void EditFunc()
        {
            printf(EditFunc\n);
        }
        程序输出为：
            FileFunc
            EditFunc
三、指针的指针
    指针的指针看上去有些令人费解。它们的声明有两个星号。例如：
        char ** cp;
    如果有三个星号，那就是指针的指针的指针，四个星号就是指针的指针的指针的指针，依次类推。当你熟悉了简单的例子以后，就可以应付复杂的情况了。当然，实际程序中，一般也只用到二级指针，三个星号不常见，更别说四个星号了。
    指针的指针需要用到指针的地址。
        char c='A';
        char *p=&c;
        char **cp=&p;
    通过指针的指针，不仅可以访问它指向的指针，还可以访问它指向的指针所指向的数据。下面就是几个这样的例子：
        char *p1=*cp;
        char c1=**cp;
    你可能想知道这样的结构有什么用。利用指针的指针可以允许被调用函数修改局部指针变量和处理指针数组。
        void FindCredit(int **);
        main()
        {
            int vals[]={7,6,5,-4,3,2,1,0};
            int *fp=vals;
            FindCredit(&fp);
            printf(%d\n,*fp);
        }
        void FindCredit(int ** fpp)
        {
            while(**fpp!=0)
            if(**fpp<0) break;
            else (*fpp)++;
        }
    首先用一个数组的地址初始化指针fp，然后把该指针的地址作为实参传递给函数FindCredit()。FindCredit()函数通过表达式**fpp间接地得到数组中的数据。为遍历数组以找到一个负值，FindCredit()函数进行自增运算的对象是调用者的指向数组的指针，而不是它自己的指向调用者指针的指针。语句(*fpp)++就是对形参指针指向的指针进行自增运算的。但是因为*运算符高于++运算符，所以圆括号在这里是必须的，如果没有圆括号，那么++运算符将作用于二重指针fpp上。
四、指向指针数组的指针
    指针的指针另一用法旧处理指针数组。有些程序员喜欢用指针数组来代替多维数组，一个常见的用法就是处理字符串。
        char *Names[]=
        {
             Bill,
             Sam,
             Jim,
             Paul,
             Charles,
             0
        };
        main()
        {
            char **nm=Names;
            while(*nm!=0) printf(%s\n,*nm++);
        }
    先用字符型指针数组Names的地址来初始化指针nm。每次printf()的调用都首先传递指针nm指向的字符型指针，然后对nm进行自增运算使其指向数组的下一个元素(还是指针)。注意完成上述认为的语法为*nm++，它首先取得指针指向的内容，然后使指针自增。
    注意数组中的最后一个元素被初始化为0，while循环以次来判断是否到了数组末尾。具有零值的指针常常被用做循环数组的终止符。程序员称零值指针为空指针(NULL)。采用空指针作为终止符，在树种增删元素时，就不必改动遍历数组的代码，因为此时数组仍然以空指针作为结束。
结构是由基本数据类型构成的、并用一个标识符来命名的各种变量的组合。结构中可以使用不同的数据类型。
一、结构说明和结构变量定义
    在Turbo C中,结构也是一种数据类型,可以使用结构变量,因此,象其它类型的变量一样, 在使用结构变量时要先对其定义。
    定义结构变量的一般格式为:
        struct 结构名
        {
            类型  变量名;
            类型  变量名;
                ...
        } 结构变量;
    结构名是结构的标识符不是变量名。
    类型为第二节中所讲述的五种数据类型(整型、浮点型、字符型、指针型和无值型)。
    构成结构的每一个类型变量称为结构成员,它象数组的元素一样,但数组中元素是以下标来访问的,而结构是按变量名字来访问成员的。
    下面举一个例子来说明怎样定义结构变量。
  
        struct string
        {
            char name[8];
            int age;
            char sex[4];
            char depart[20];
            float wage1,wage2,wage3;
        }person;
               
    这个例子定义了一个结构名为string的结构变量person,如果省略变量名person,则变成对结构的说明。用已说明的结构名也可定义结构变量。这样定义时上例变成:
        struct string
        {
            char name[8];
            int age;
            char sex[4];
            char depart[20];
            float wage1,wage2,wage3;
        };
        struct string person;
    如果需要定义多个具有相同形式的结构变量时用这种方法比较方便,它先作结构说明,再用结构名来定义变量。
    例如:
        struct string Tianyr, Liuqi, ...;
    如果省略结构名,则称之为无名结构,这种情况常常出现在函数内部,用这种结构时前面的例子变成:
         struct
         {
             char name[8];
             int age;
             char sex[4];
             char depart[20];
             float wage1,wage2,wage3;
         } Tianyr, Liuqi;
二、结构变量的使用
    结构是一个新的数据类型,因此结构变量也可以象其它类型的变量一样赋值、运算,不同的是结构变量以成员作为基本变量。
    结构成员的表示方式为:
        结构变量.成员名
    如果将结构变量.成员名看成一个整体,则这个整体的数据类型与结构中该成员的数据类型相同,这样就可象前面所讲的变量那样使用。
    下面这个例子定义了一个结构变量,其中每个成员都从键盘接收数据,然后对结构中的浮点数求和,并显示运算结果。请注意这个例子中不同结构成员的访问。
        #include <stdio.h>
        main()
        {
            struct
            {                  /*定义一个结构变量*/
                char name[8];
                int age;
                char sex[4];
                char depart[20];
                float wage1,wage2,wage3;
            }a;
            float wage;
            char c='Y';
            while(c=='Y'||c=='y')         /*判断是否继续循环*/
            {
                printf(\nName:);
                scanf(%s, a.name);     /*输入姓名*/
                printf(Age:);
                scanf(%d, &a.wage);    /*输入年龄*/
                printf(Sex:);
                scanf(%s, a.sex);
                printf(Dept:);
                scanf(%s, a.depart);
                printf(Wage1:);
                scanf(%f, &a.wage1);   /*输入工资*/
                printf(Wage2:);
                scanf(%f, &a.wage2);
                printf(Wage3:);
                scanf(%f, &a.wage3); 
                wage=a.wage1+a.wage2+a.wage3;
                printf(The sum of wage is %6.2f\n, wage);
                printf(Continue?<Y/N>);
                c=getche();
            }
        }
三、结构数组和结构指针
    结构是一种新的数据类型, 同样可以有结构数组和结构指针。
    1.结构数组
        结构数组就是具有相同结构类型的变量集合。假如要定义一个班级40个同学的姓名、性别、年龄和住址, 可以定义成一个结构数组。如下所示:
            struct
            {
                char name[8];
                char sex[4];
                int age;
                char addr[40];
            }student[40];
        也可定义为:
            struct string
            {
                char name[8];
                char sex[4];
                int age;
                char addr[40];
            };
            struct string student[40];
        需要指出的是结构数组成员的访问是以数组元素为结构变量的, 其形式为:
            结构数组元素.成员名
        例如:
            student[0].name
            student[30].age
        实际上结构数组相当于一个二维构造, 第一维是结构数组元素, 每个元素是一个结构变量, 第二维是结构成员。
        注意:
            结构数组的成员也可以是数组变量。
        例如:
            struct a
            {
                int m[3][5];
                float f;
                char s[20];
            }y[4];
        为了访问结构a中结构变量y[2]的这个变量, 可写成y[2].m[1][4]
    2.结构指针
        结构指针是指向结构的指针。它由一个加在结构变量名前的* 操作符来定义, 例如用前面已说明的结构定义一个结构指针如下:
            struct string
            {
                char name[8];
                char sex[4];
                int age;
                char addr[40];
            }*student;
        也可省略结构指针名只作结构说明, 然后再用下面的语句定义结构指针。
            struct string *student;
        使用结构指针对结构成员的访问, 与结构变量对结构成员的访问在表达方式上有所不同。结构指针对结构成员的访问表示为:
            结构指针名->结构成员              
        其中->是两个符号-和>的组合,好象一个箭头指向结构成员。例如要给上面定义的结构中name和age赋值,可以用下面语句:
            strcpy(student->name, Lu G.C);
            student->age=18;
        实际上, student->name就是(*student).name的缩写形式。
            需要指出的是结构指针是指向结构的一个指针, 即结构中第一个成员的首地址, 因此在使用之前应该对结构指针初始化, 即分配整个结构长度的字节空间,这可用下面函数完成, 仍以上例来说明如下:
                student=(struct string*)malloc(size of (struct string));
                size of (struct string)自动求取string结构的字节长度,malloc()函数定义了一个大小为结构长度的内存区域, 然后将其诈地址作为结构指针返回。
        注意:
            1. 结构作为一种数据类型,因此定义的结构变量或结构指针变量同样有局部变量和全程变量, 视定义的位置而定。
            2. 结构变量名不是指向该结构的地址,这与数组名的含义不同,因此若需要求结构中第一个成员的首地址应该是&[结构变量名]。
            3. 结构的复杂形式：嵌套结构
        嵌套结构是指在一个结构成员中可以包括其它一个结构,Turbo C允许这种嵌套。
            例如: 下面是一个有嵌套的结构
                struct string
                {
                    char name[8];
                    int age;
                    struct addr address;
                } student;
            其中: addr为另一个结构的结构名, 必须要先进行, 说明, 即
                struct addr
                {
                    char city[20];
                    unsigned lon zipcode;
                    char tel[14];
                }
            如果要给student结构中成员address结构中的zipcode赋值, 则可写成:
                student.address.zipcode=200001;
            每个结构成员名从最外层直到最内层逐个被列出,即嵌套式结构成员的表达方式是:
                结构变量名.嵌套结构变量名.结构成员名
            其中: 嵌套结构可以有很多,结构成员名为最内层结构中不是结构的成员名。
联合(union)：
一、联合说明和联合变量定义
    联合也是一种新的数据类型, 它是一种特殊形式的变量。
    联合说明和联合变量定义与结构十分相似。其形式为:
        union 联合名
        {
            数据类型 成员名;
            数据类型 成员名;
                 ...
        }联合变量名;
    联合表示几个变量公用一个内存位置,在不同的时间保存不同的数据类型和不同长度的变量。
    下例表示说明一个联合a_bc:
        union a_bc
        {
            int i;
            char mm;
        };
    再用已说明的联合可定义联合变量。
    例如用上面说明的联合定义一个名为lgc的联合变量,可写成:
        union a_bc lgc;
    在联合变量lgc中, 整型量i和字符mm公用同一内存位置。
    当一个联合被说明时, 编译程序自动地产生一个变量,其长度为联合中最大的变量长度。
    联合访问其成员的方法与结构相同。同样联合变量也可以定义成数组或指针,但定义为指针时,也要用->符号, 此时联合访问成员可表示成:
        联合名->成员名
    另外, 联合既可以出现在结构内, 它的成员也可以是结构。
    例如:
        struct
        {
            int age;
            char *addr;
            union
            {
                int i;
                char *ch;
            }x;
        }y[10];
    若要访问结构变量y[1]中联合x的成员i, 可以写成:
        y[1].x.i;
    若要访问结构变量y[2]中联合x的字符串指针ch的第一个字符可写成:
        *y[2].x.ch;
    若写成y[2].x.*ch;是错误的。
二、结构和联合的区别
    1. 结构和联合都是由多个不同的数据类型成员组成,但在任何同一时刻,联合中只存放了一个被选中的成员, 而结构的所有成员都存在。
    2. 对于联合的不同成员赋值,将会对其它成员重写,原来成员的值就不存在了,而对于结构的不同成员赋值互不影响的。
    下面举一个例了来加深对联合的理解。
        main()
        {
            union
            {                   /*定义一个联合*/
                int i;
                struct
                {             /*在联合中定义一个结构*/
                    char first;
                    char second;
                }half;
            }number;
            number.i=0x4241;         /*联合成员赋值*/
            printf(%c%c\n, number.half.first, mumber.half.second);
            number.half.first='a';   /*联合中结构成员赋值*/
            number.half.second='b';
            printf(%x\n, number.i);
            getch();
        }
        输出结果为:
            AB
            6261
    从上例结果可以看出: 当给i赋值后, 其低八位也就是first和second的值;当给first和second赋字符后,这两个字符的ASCII码也将作为i 的低八位和高八位。
    简单的说，就是联合里面的所有变量共用一个内存区域，区域大小是所有变量中最大的那个。改动某一个变量的值，其他的值也会随之改变。
枚举(enum)
    枚举是一个被命名的整型常数的集合,枚举在日常生活中很常见。
               
    例如表示星期的SUNDAY,MONDAY,TUESDAY,WEDNESDAY,THURSDAY,FRIDAY,SATURDAY,就是一个枚举。
    枚举的说明与结构和联合相似, 其形式为:
        enum 枚举名
        {
            标识符[=整型常数],
            标识符[=整型常数],
                   ...
            标识符[=整型常数],
        }枚举变量;
        如果枚举没有初始化,即省掉=整型常数时,则从第一个标识符开始,顺次赋给标识符0,1,2, ...。但当枚举中的某个成员赋值后, 其后的成员按依次加1的规则确定其值。
        例如下列枚举说明后,x1, x2, x3, x4的值分别为0, 1, 2, 3。
            enum string{x1, x2, x3, x4}x;
        当定义改变成:
            enum string
            {
                x1,
                x2=0,
                x3=50,
                x4,
            }x;
            则x1=0, x2=0, x3=50, x4=51
    注意:
        1. 枚举中每个成员(标识符)结束符是,,  不是;, 最后一个成员可省略,。
        2. 初始化时可以赋负数, 以后的标识符仍依次加1。
        3. 枚举变量只能取枚举说明结构中的某个标识符常量。
    例如:
        enum string
        {
            x1=5,
            x2,
            x3,
            x4,
        };
        enum strig x=x3;
        此时, 枚举变量x实际上是7。
        下面看一个例子：
            main()
            {
                enum colors {red=1,green,blue}col;
                int cl;
                printf(1=red,2=green,3=blue.  seclect: );
                scanf(%d,&cl);
                col=(enum colors) cl;      /*强制转换*/
                switch(col)
                {
                    case red:
                            printf(red\n);
                            break;
                    case green:
                            printf(green\n);
                            break;
                    case blue:
                            printf(blue\n);
                            break;
                    defalut:
                            break;
                }
            }
            
           * **类型说明** *
 
    类型说明的格式为:
        typedef 类型 定义名;
    类型说明只定义了一个数据类型的新名字而不是定义一种新的数据类型这里类型是Turbo C许可的任何一种数据类型定义名表示这个类型的新名字。
    例如: 用下面语句定义整型数的新名字:
        typedef int SIGNED_INT;
    使用说明后, SIGNED_INT就成为int的同义词了,此时可以用SIGNED_INT定义整型变量。
    例如:  SIGNED_INT i, j;(与int i, j等效)。
    但 long SIGNED_INT i, j; 是非法的。
    typedef同样可用来说明结构、联合以及枚举。
    说明一个结构的格式为:
        typedef struct
        {
             数据类型  成员名;
             数据类型  成员名;
                   ...
        } 结构名;
    此时可直接用结构名定义结构变量了。例如:
        typedef struct
        {
            char name[8];
            int class;
            char subclass[6];
            float math, phys, chem, engl, biol;
        }student;
        student Liuqi;
    则Liuqi被定义为结构数组和结构指针。
我们经常在题目中有要求，输入一个整数，然后以这个整数作为数组的元素个数，下面的程序代码是错误的。
    int n,array[n];
    scanf(%d,&n);
在Turbo C中，不允许出现动态数组。那么如果必须需要这样时，就只能使用链表了。