ex12.cpp

C／C＋＋程序设计教程

               pAdd->pNext=pFind; //插入位置在表尾的结点前,链头之后
           }                     //[pPrev]< [pAdd]<= [pFind]<[...]<=[Tail]
		 else    //此时pFind->pNext=0同时 pFind->elem<key
			{ pFind->pNext=pAdd;   	   //插入位置在原先表尾之后
              pAdd->pNext=NULL;       // [pFind= tail ]<= [pAdd]
            }
     return pHead;                          //返回原来的表头
  }
    void Show(SList* p) 
	{  for(int k=1;p!=0;p=p->pNext,k++) 
		   printf("[%d,%c]-",p->elem,p->data);
	   printf("\n");
	}
    SList  a={ 6,'a',NULL};      //定义全局结构变量a和数组d
	SList  d[]={8,'d',NULL,5,'d',NULL,4,'d',NULL,9,'d',NULL};	                
    void main()
 	{  	 const int n=sizeof(d)/sizeof(SList);       //计算结构数组d的维数
	     SList c[n]={7,'c',0,5,'c',0,4,'c',0,9,'c',0};   //定义局部结构数组c
		 SList    *pBegin=0;		      //设置一个局部指针旨在指向链表的头结点 
		 int k ;for(k=n-1;k>=0;k--)       //将数组c元素的地址作为插入结点实参	 
               pBegin=Insert(pBegin,&c[k]);   //根据从小到大的次序形成链表
         Show(pBegin);
         for( k=0;k<n;k++)              //将数组d元素的地址作为插入结点实参
          pBegin=Insert(pBegin,d+k);
		 Show(Insert(pBegin,&a));      //将a结点加入pBegin为首的链表
	}	/*输出结果如下*/
////////////[例12.12]将一个结点从链表中脱离出来
    # include <stdio.h>    
	typedef  struct  SList_tag
	{ 	  int    elem; char  data;
		 struct  SList_tag* pNext;
	} SList;
	SList*   Detach(SList*pHead,int  key)
	 { if(pHead==NULL)             //头结点是空指针无功返回
        {printf("NULL List\n");return pHead;}	  
	  if(key==pHead->elem)
		{  pHead=pHead->pNext;   //原头结点的下属升为新的头结点
			printf("the Head element=%d detached\n",key);
			return pHead;           //返回新的链首
	   }
	  SList*pFind=pHead;           // pFind是搜寻捕获要脱离的探针
	  SList*pPrev;                 // pPrev纪录捕获结点的前结点
      while(key!=pFind->elem&&pFind->pNext!=NULL)
		{       //未探到要找的结点同时后面尚有结点，继续循环//    
		  pPrev=pFind;
		  pFind=pFind->pNext;
		}    
	   if(key==pFind->elem)            //找到了结点
		{  pPrev->pNext=pFind->pNext;  //建立新的关联
			printf("the element=%d detached\n",pFind->elem);
	    }
	   else  printf("element not found\n"); //原链表中无筛选尺度所指定的结点
	   return pHead;                         //返回原来的表头
   }
	extern void Show(SList* p) ;
	extern	SList* Insert(SList*pHead,SList*pAdd);
	SList  d[]={8,'d',0,5,'d',0,4,'d',0,9,'d',0};//定义全局结构数组d	                
    void main(void)
 	{  	 SList    *pOldH=0; 		 
		 for(int k=0;k<4;k++) 
           pOldH=Insert(pOldH,d+k);        //输出结果如下：
		 Show(pOldH);		     	     //[4,d]-[5,d]-[8,d]-[9,d]-
		 SList* pNewH =Detach(pOldH,4);	//the Head element=4 detached
		 Show(pNewH);                    //[5,d]-[8,d]-[9,d]-
		 Show(pOldH);                     //[4,d]-[5,d]-[8,d]-[9,d]-
	}	

//////////////[例12.13] 联合的内存和结构的内存大小比较
    #include<stdio.h>   
    typedef   struct s_a {  double d; char   c[9]; } A;// 结构A的长度为24
    typedef   struct s_b {  double d; long   k[2];} B; // 结构B的长度为16
    typedef   union u_t {   A  a;  B  b; } U;    //联合U的长度单独由成员a确定
    typedef   struct s_t {   A  a;  B  b; } S;    //结构S的长度是成员a和b长度之和
 	void main (void)
    {   printf("sizeof(A)=%d,",sizeof(A));  	    printf("sizeof(B)= %d,",sizeof(B));
		printf("sizeof(U)= %d,",sizeof(U));		printf("sizeof(S)= %d",sizeof(S));	
	}   //输出:sizeof(A)= 24,sizeof(B)= 16,16,sizeof(U)= 24,24,sizeof(S)= 40
/////////////[例12.14] 联合指针入口形参和联合引用返回 
	#include<stdio.h>    
    inline  int  f(int k){return k;}
	typedef union u_t	{  char*  s;	int (*f)(int);  int d; } Un ;
	Un& initial(Un*p ,int n,char * s)  //成员名s,f在全局函数中不单独使用
	{	switch(n)                 //单独使用的名称s,f具有其它的含义
		  {	case 1:   p->s=s; break;//char*型局部指针s初始化字符指针成员s
			case 2:   p->f=f; break; //全局函数名f初始化int (*)(int)型的函数指针成员
			default:  p->d=n;break;//对 int 型的变量成员d赋值
		  }                     //三个成员互斥地使用同一内存
	    return *p;                
	}
 	void main (void)
    {   Un x;
	  	for(int n=1;n<4;n++)
      	{ Un y= initial(&x,n,"abcd");
	  		switch(n)
		  	{	case 1:    printf("[%s,%s]\t",x.s,y.s);       break;
				case 2:    printf("[%d,%d]\t",x.f(1),y.f(2));  break;
				default:   printf("[%d,%d]\n",x.d,y.d);      break;
		  	}
      	}     	  
	}		  //输出：[abcd,abcd]		[1,2]    [3,3]
/////////////[例12.15] 强制类型转换显示低尾端存储格式(8位二进制数的低位在右边，高位在左边)
	#include<stdio.h>
	void main()
	{  	unsigned long m=0x87654321UL;
		unsigned char *  p=(unsigned char*)&m;
		for(int i=0;i<sizeof(long);i++)    printf("%x ",*p++);
	}      //低尾端的PC计算上输出结果：21 43 65 87
/////////////[例12.16] 联合的内存布局和内存数据的解释
   #include<stdio.h>
    typedef union u_t       {    char c[2];        unsigned  long k;        }  U;
    void main()  
	{   U   x =   {3,1};   //x.c[0]=3;x.c[1]=1;  潜在地导致x.c[2]=0;x.c[3]=0;
	    printf("%d,0x%08x\t",x.k,x.k);
	    x.k= 0x67686162UL;
	    printf("%c,%d,%c,%d;  ",x.c[0],x.c[0],x.c[1],x.c[1]);
	    printf("%c,%d,%c,%d\n ",x.c[2],x.c[2],x.c[3],x.c[3]);// "越界"索引字符成员数组元素
	}   //输出：259,0x00000103    b,98,a,97;   h,104,g,103
//////////	 [例12.17]浮点数和整型数内存存储格式不同
	#include<stdio.h>
    typedef union u_fl   {   float  f;     long   k;   } Ua;
    typedef union u_il   {   int    f;     long   k;   } Ub;	
    //struct Sab  { Ua  a;  Ub b;} s={ 1.0,2 };这个结构的声明相当于下面的结构
    struct Sab  { union {float  f ;  long k;} a;  Ub b;} s={ 1.0,2 };
    void main()  //Sab结构中两个成员是联合变量，联合变量s.a的类型相当于Ua类型
	{   printf("[%1.0f,%d]\t",s.a.f,s.b.f);
		Ua &   x=(Ua &)s.a ; //引用x是联合变量s.a的别名,此处显式类型转换是必须的
	  	x.f=10;	     printf("[%d,%d]\t",(long)(x.f+s.a.f),x.k);// x.k输出结果1092616192
	  	x.k=20;	     printf("[%d,%d]\t",(long)x.f,x.k+s.a.k);// (long)x.f输出结果0
	  	Ub &   y=s.b ;    //引用y是联合变量s.b的别名
	  	y.f=10;	     printf("[%d,%d]\t",(long)y.f,s.b.k);
	  	y.k=20;	     printf("[%d,%d]\n",(long)s.b.f,y.k);
	}   //输出：[1,2]   [20,1092616192]    [0,40]    [10,10]    [20,20]
///////////[例12.18] 无名联合直接定义局部共享的多个变量n,m, x, y。
    #include<stdio.h>     
 	void main (void)
    {   union 	{	int    n; 	long   m;     double x;    double y;	} ;
               printf("[%p,%p]\t",&n,&y);
	    n=3;	   printf("[%d,%d]\t",n,m);
	    x=6;    printf("[%f,%f]\n",x,y);
	}//输出：[0065FDF0,0065FDF0]  [3,3]  [6.000000,6.000000]
 ///////   [例12.19]无名联合 static union{ point_t  z; point3d b;};定义静态全局结构变量b和z
	# include <stdio.h>    
    typedef  struct   {   double   v[3];   }   point_t;
    typedef  struct   {   double   x,y,z;  }   point3d;
	typedef union 	{ point_t  z;	 point3d  b;} Ua ;   //结构变量作为联合Ua的成员
    point3d*  CrossProduct( point3d  in1, point3d&  a)
	{   const   point3d  in2=a;
		a.x = in1.y * in2.z - in1.z * in2.y;
		a.y = in1.z * in2.x - in1.x * in2.z;
		a.z = in1.x * in2.y - in1.y * in2.x;
		return &a;
	}
	static  union	{      point_t     z;	        point3d     b;	};
	extern point_t * q;          // 外部连接属性的全局指针
	const point3d  x={1,1,0};	
	point_t*   q;
	void main(void)
	{  b.x=0;   b.y=2;   b.z=1;
	  q=(point_t*)CrossProduct(x,b);  
	  if( b.x==z.v[0] &&  b.y==z.v[1] && b.z==z.v[2]) 	     
	      printf("b={%4.1f,%4.1f,%4.1f}\t", b.x, b.y,b.z);
	  printf("q={%4.1f,%4.1f,%4.1f}\t", q->v[0], q->v[1], q->v[2]);
	  Ua a={1,2,3};             //对联合的第一个结构变量成员z初始化
	  printf("a={%4.1f,%4.1f,%4.1f}\n", a.b.x, a.b.y,a.b.z);//输出第2个成员b的值
	}  //输出:  b={ 1.0,-1.0, 2.0}       q={ 1.0,-1.0, 2.0}  a={ 1.0, 2.0, 3.0}
/////////[例12.20] 结构范围中的无名联合实现不同课题组之间的数据接口
	# include<stdio.h>  
    # include<string.h>  
    typedef struct a_t                         //结构中实际上只有三个独立的成员
	{  union {  int   n;  int   number;  };	   //成员名称n和number是等价的
	   union {  float f;   float  income;  };    //成员名称f和income是同等的
	   union {  char *s;  char  *name;   };	   //成员名称s和name是合一的
	}        A,          B;  
   int SeqFind(const B s[],int n,float  key)    //浮点型变量key作为待查的关键指标
   {                                        //顺序查找关键字key对应的数组元素
    for(int i=0;i<n;i++)                         //从数组元素的起始依次与关键字比较
	     if(s[i].income==key) return i;                 //如果相等则返回数组的下标
     return -1;                                //否则返回-1这个失败标志
   }
   int SeqFind(const A s[],int n,const char* key) //顺序或线性查找算法
   {                                         //字符串指针key作为查找的标准
    for(int i=0;i<n;i++)
	     if(strcmp(s[i].s,key)==0) return i;         //调用字符串比较函数strcmp进行判断
     return -1;
   }
   void InitData(B  b[],int n[],float f[],char (*s)[20],int num=5)
   {                                      //对结构数组的成员进行初始化的函数
	   for(int i=0;i<num;i++)
	    {	  b[i].number=n[i];		b[i].income=f[i];  
              b[i].name =s[i];	              //指针通过赋值语句初始化
		}   
   }   
   void show(B& r)                    //引用语法输出结构变量的成员
   { printf("{%d,%f,%s}\t",r.number,r.income,r.name); }
   void show(A* s,int n)                //指针语法输出结构数组的成员
   {   for(A*p=s;p<s+n;p++)      printf("{%d,%4.1f,%s},",p->n,p->f,p->s);
	   printf("\n");
   }
   const int N=5;
   static   char ca[N][20]={"Hisen","Boir","Rose","Bush","Kelin"};
   void main()
   {   static     int na[N]={11,22,33,44,55};
       float        xa[N]={88,90,70,80,60};  	  A  sa[N];
       InitData(sa,na,xa,ca,N);                    show(sa,N);
	   int k=SeqFind(sa,N,"Rose");	   if(k!=-1)    show(sa[k]);
          k=SeqFind(sa,N,60);	       if(k!=-1)    show(sa[k]);
  }//输出结果:
////////[例12.21] 结构变量的类型转换与复制
   #include <stdio.h>
	typedef struct sa  {   int m;     }   A; 
	typedef struct sb  {   int x;  int y;  } B;
	void show(B& b)	{	printf("b={%d,%d}\t",b.x,b.y);	}
	void main()
	{   A	  a={1};          B    b={3,4};     
	   (struct sa&)b=a;	     show(b);
	   a.m=8; b=(B &)a;   show(b);	/*越界复制b.z的值不定*/
	}        //程序输出：b={1,4}   b={8, 6684216}




1