typedef用法详解

/* 为了从易到难地使用typedef，现将C++数据类型按照类型名的来源和复杂性重分类如下：
一、基本类型（类型名是系统指定的单一标识符）
in,char,float,double,void,const
二、自定义类型（类型名是用户定义的单一标识符）
1.结构类型
struct stru{int i;struct stru*;};
2.共用类型
union unio{int i;enum num[10];};
3.枚举类型
enum num{a,b,c};
4.typedef类型
typedef double db;
三、派生类型（类型名由已有类型与其它符号组合而成）
1.指针类型（由 已有类型* 组成）
void*,char**,void(*)(),struct stru*,enum num*
2.数组类型（由 已有类型[][] 组成）
int[3][4],struct stru[10],enum num[10],char*[10]
3.函数类型（类型名是各种符号组成的函数原型）
void main(void),char* strcpy(char*,char*)

以上三大类别的类型标识符由简单到复杂，学习typedef时要依照先后顺序，练习每种类型的重定义
每定义出一种新类型后，从以下几个方面使用它：用它定义变量、指针、数组、带存储类别的对象、
带const的对象；用它作函数参数和返回值类型；用它进行类型转换；用sizeof求长度*/

#include<stdio.h>
#include<stdlib.h>
void main()
{
  //一、重定义基本类型
  //1.定义
  typedef int in;
  typedef char ch;
  typedef float fl;
  typedef double db;
  typedef unsigned int ui;//或写为typedef unsigned ui;
  typedef unsigned char uc;
  typedef void vo;

  //2.使用
  in i=3;  printf("i=%d",i);  //用新类型定义变量
  ch* pc="pc";  printf("pc=%s",pc);//用新类型定义指针
  fl af[3]={1,2,3};  printf("af[0]=%f",af[0]);//用新类型定义数组
  static double sd;  printf("sd=%f",sd);//用新类型定义带存储类别的变量
  const ui cui=3;  printf("cui=%d",cui);//用新类型定义带类型限定符的变量
  vo fun1(uc);  fun1('a');//用新类型作函数的参数和返回值类型
  printf("in(1.5)=%d",in(1.5));//将新类型用作类型转换
  printf("$db=%d",sizeof(db));//对新类型求长度，$db=$double=8

  //二、重定义自定义类型
  //1.定义
  //(1)完整写法(先定义好自定义类型，再重定义它)
  struct datetype                 //重定义结构类型
  { ui year;//ui即是unsigned int;
    uc month;//uc即是unsigned char;
    uc day;};
  typedef datetype date;
  union scoretype                 //重定义共用类型
  { fl sco1;
    ch* sco2;};
  typedef scoretype score;
  enum numtype{one,two,three};    //重定义枚举类型
  typedef numtype num;
  typedef num newnum;             //重定义typedef类型

  //(2)通常写法(对无类型名的结构、共用、枚举定义语句直接重定义)
  typedef struct{uc hou,min,sec;} time;
  typedef union{fl sco1;ch* sco2;} sco;
  typedef enum{red,green,blue} color;
  //可见，无论何种写法，都遵循typedef语句的格式：typedef 原类型  新类型;

  //2.使用
  date vs={2002,10,15};//定义结构变量
  printf("vs:%d.%d.%d",vs.year,vs.month,vs.day);
  score vu,*pu=&vu;printf("&vu=%x pu=%x",&vu,pu);//定义共用指针
  newnum ae[3]={one,two,three};//定义枚举数组
  printf("ae[0]=%d ae[1]=%d ae[2]=%d",ae[0],ae[1],ae[2]);
  static num vn;//定义带存储类别的对象
  printf("vn=%d",vn);
  const sco cs={90};//定义const对象
  printf("cs.sco1=%f",cs.sco1);
  time fun2(time);//作函数的参数和返回值类型
  static time vt=fun2(vt);
  printf("fun2:%d:%d:%d",vt.hou,vt.min,vt.sec);
  vn=(num)10;printf("vn=%d",vn);//将新类型用作类型转换
  printf("$time=%d",sizeof(time));//对新类型求长度，$time=3
  printf("$sco=%d",sizeof(sco));//对新类型求长度，$sco=4
  printf("$color=%d",sizeof(color));//对新类型求长度，$color=4

  //2.重定义数组类型
  //(1)定义
  typedef int ai[5];//重定义基本类型数组
  typedef float a2[3][4];//重定义数组型数组(二维数组)
  typedef time as[2];//重定义结构型数组
  typedef sco au[2];//重定义共用型数组
  typedef color ae2[2];//重定义枚举型数组
  typedef char* ap2[2];//重定义指针型数组
  //注：重定义数组时，C++暂不支持typedef int[10] ai这种正规写法

  //(2)使用
  //定义变量(数组变量)
  ai vai={1,2,3,4,5};//相当于int vai[5];
  printf("vai:%d %d",vai[0],vai[1]);
  //定义指针(数组指针)
  a2 va2,*pa2=&va2;//相当于float va2[3][4],(*pa2)[3][4]=&va2;
  printf("&va2=%x pa2=%x",va2,pa2);
  //定义数组(多维数组)
  as vas[2]={{10,20,30},{20,40,59}};//vas此时是二维结构数组，相当于time vas[2][2];
  printf("vas[0][0]:%d:%d:%d",vas[0][0].hou,vas[0][0].min,vas[0][0].sec);
  //定义带存储类别的数组
  static au vau;//vau是含2元素的静态共用数组
  printf("vau[2]:%f %f",vau[0].sco1,vau[1].sco1);
  //定义cosnt数组
  const ae2 cae2={red,green};//cae2是含2元素的常量枚举数组
  printf("cae2[2]:%d %d",cae2[0],cae2[1]);
  //定义函数
  void fun4(ap2);//参数是指针数组，相当于void fun4(char* ap2[2]);
  ap2 vap2={"str1","str2"};//vap2的两元素分别指向"str1"和"str2"
  fun4(vap2);
  printf("$ai=%d",sizeof(ai));//对新类型求长度，$ai=$int[5]=20
  printf("$a2=%d",sizeof(a2));//对新类型求长度，$a2=$float[3][4]=48
  printf("$as=%d",sizeof(as));//对新类型求长度，$as=$=time[2]=6
  printf("$au=%d",sizeof(au));//对新类型求长度，$au=$=sco[2]=8
  printf("$ae2=%d",sizeof(ae2));//对新类型求长度，$ae2=$color[2]=8
  printf("$ap2=%d",sizeof(ap2));//对新类型求长度，$ap2=$=char*[2]=8
  //注：因函数返回值不能是数组类型，故这里不再将重定义类型用作函数返回值类型

  //3.重定义函数类型
  //(1)定义方法
  int fun(int,int);//声明了一个函数，它有两个整型参数、返回值为整型
  typedef int FUN(int,int);//定义了一个类型，它代表含两个整型参数、返回值为整型的函数

  //(2)使用方法
  //定义变量(函数)
  FUN max,min;//用类型FUN定义了两个对象max和min，因FUN是函数类型，故它们自然是函数对象
  //这里相当于int max(int,int)和int min(int,int)两个声明
  printf("max(3,5)=%d",max(3,5));//调用这两个函数
  printf("min(3,5)=%d",min(3,5));
  //定义指针(函数指针)
  FUN* pfun;//pfun是一种指针，它专门指向FUN类型的对象。相当于定义int(*pfun)(int,int);
  pfun=max;//max和min都是FUN类型的对象
  printf("&max=%x pfun=%x",max,pfun);
  //其它使用基本无意义，略

  //可见，若程序中要用到许多类型相同但名称不同的函数，可先用typedef抽象出类型，再用该类型
  //一次便可声明许多函数，以简化函数原型的书写。但这种类型只能用来声明函数，而不能用来定义函数

} //main end

//下面是main中用到的函数
void fun1(unsigned char p)//因vo与uc的作用域不在此处，故这里直接使用void和unsigned
{ printf("fun1:%c",p);//这样与函数原型vo fun1(uc)亦对应
}

typedef struct{unsigned char hou,min,sec;} time;//因main中的time类型作用域已结束，故这里要使用必须重新定义
time fun2(time p)
{ p.hou=20;p.min=30,p.sec=55;
  return p;}
/*注：严格来说这里的time与main中函数原型里的time并不是同一类型，但系统忽略了这点
正确用法应将main中的time作为全局类型定义在程序开头，这样其后的函数都可共享使用该类型*/

void* fun3(float** p)
{ printf("fun3:malloc(%d)",p);
  return malloc(int(p));
}

typedef char* ap2[2];
void fun4(ap2 p)
{ printf("fun4:p[0]=%s p[1]=%s",p[0],p[1]);
}

int max(int a,int b)
{ return a>b?a:b;
}

int min(int a,int b)
{ return a<b?a:b;
}

             typedef与define的区别
  //用define也可实现简单的类型替换，如
  #define INT long //用INT来代替long
  //两种方式的区别如下：
  //1.二者处理时间不同，宏替换是在预编译时进行的，而类型定义是在正式编译时处理的
  //2二者本质不同，宏替换只是将宏名简单替换为目标字符串，而类型定义如同定义变量一样
  //是真的为程序增加了一种可用类型
  //3.二者复杂性不同，用typedef可定义各种复杂的类型，并以各种方式使用新类型(详见10_10_2.cpp)
  //而define只能替换基本类型和自定义类型，无法替换派生类型，且使用起来很不安全，例如
  #define pi int* //试图用pi代替整型指针
  pi pi1;//正确，展开后为int* pi1;
  pi pi2,pi3;//错误，原意是将pi2,pi3都定义成整型指针，但展开后为int* pi2,pi3; pi3并未定义成指针

  #define NUM enum{one,two,three}//试图用NUM代替该枚举类型
  NUM n1;//正确，定义了枚举常量one,two,three和枚举变量n1
  //NUM n2;//错误，展开后为enum{one,two,three}n2;从而造成枚举常量one,two,three的重定义

  #define DATE struct{int y,m,d;}
  DATE *pd;//正确，定义了该结构型指针
  //pd=(DATE)1;//错误，展开后为pi=(struct{int y,m,d;})1;目前尚不支持此种类型转换写法

  #define TIME union{int h,m,s;}
  //int L=sizeof(TIME);//错误，展开后为int L=sizeof(union{int h,m,s;});sizeof操作数错误
  //可见，用define进行类型替换时，会产生各种意想不到的错误，故应避免使用，而改用安全的typedef