// 动态存储分配 
int  i,  * pi;
float  i,  * pf;
pi  =  ( int   * )malloc( sizeof ( int ));
pf  =  ( float   * )malloc( sizeof ( float ));
//
free(pi);
free(pf);

// 以上的等价代码
if ( ! (pi  =  ( int   * )malloc( sizeof ( int ))))  ||
     ! (pf  =  ( float   * )malloc( sizeof ( float )))  {
         // printf error
        exit(EXIT_FAILURE);
} // if

// 因为malloc在程序中经常出现 所以使用宏.
#define  MALLOC(p, s)\
     if ( ! ((p)  =  malloc(s)))  {\
     /**/ /* printf error */ \
    exit(EXIT_FAILURE);\
    }
// 现在我们可以用以下的命令来调用malloc
MALLOC(pi,  sizeof ( int ));
MALLOC(pf,  sizeof ( float ));

/**/ //////////////////////////////////////////
//  Example1
//  begin-----------Hanoi.cpp : 定义控制台应用程序的入口点。
/**/ ///////////////////////////////////////////// /
#include  " stdafx.h "
#include  < iostream >

static   int  times  =   0 ;
void  move( char  beginning,  int  num,  char  end);
void  hanoi( int  n,  char  A,  char  B,  char  C /**/ /* , int i */ );
int  _tmain( int  argc, _TCHAR *  argv[])
{
     int  number;
    scanf( " %d " ,  & number);
    hanoi(number,  ' x ' ,  ' y ' ,  ' z ' );
    scanf( " %d " ,  & number);
     return   0 ;
}

void  move( char  beginning,  int  num,  char  end)
{
    times ++ ;
    printf( " %d : Number %d From %c to %c\n " , times, num, beginning, end);

}

void  hanoi( int  n,  char  A,  char  B,  char  C /**/ /* , int i */ )
{
     if  (n  ==   1 )
        move(A,  1 , C);
     else   {
        hanoi(n - 1 , A, C, B /**/ /* , i */ );
        move(A, n, C);
         /**/ /* i++; */
        hanoi(n - 1 , B, A, C /**/ /* , i */ );
    } // else
}



/**/ ///////////////////////////////////////////// /
//  Make2dArray
/**/ ////////////////////////////////////////// //
int   ** make2dArray( int  rows,  int  cols)
{
     int   ** x, i;
    MALLOC(x, rows  *   sizeof ( * x));
     for (i  =   0 ; i  <  rows; i ++ )
        MALLOC(x[i], cols  *   sizeof ( ** x));
     return  x;
}
// use
int   ** myArray;
myArray  =  make2dArray( 5 ,  10 );

// structure
typedef  struct   {
     enum  tagField  {female, male}  sex;
    union  {
         int  children;
         int  beard;
    }  u;
}  sexType;

typedef  struct   {
     char  name[ 10 ];
     int  age;
     float  salary;
    sexType sexInfo;
}  humanBeing;

humanBeing person1, person2;
person1.sexInfo.sex  =  male;
person2.sexInfo.u.beard  =  FALSE;

/**/ /////////////////////////////////////////////////// /
//  fread fopen--1
/**/ //////////////////////////////////////////////// //
#include  " stdafx.h "
#include  < stdio.h >
#include  < conio.h >
#include  < stdlib.h >

int  _tmain( int  argc, _TCHAR *  argv[])
{
     int  ch;
    FILE  * fp;
     char  fname[ 50 ];
    printf( " input a filename :  " );
    scanf( " %s " , fname);
    fp  =  fopen(fname,  " r " );
     if ( ! fp)  {
        printf( " error! " );
        exit( 1 );
    } // if
     while ((ch  =  getc(fp))  !=  EOF)
        putchar(ch);
    fclose(fp);
    getch();
     return   0 ;
}



/**/ ///////////////////////////////////////////// //
//  beginning---2-----fileopen fread
/**/ ///////////////////////////////////////////// /
#include  " stdafx.h "
#include  < stdio.h >
#include  < conio.h >
#include  < stdlib.h >

int  _tmain( int  argc, _TCHAR *  argv[])
{
     int   ** data;
    FILE  * fp;
    fp  =  fopen( " h.txt " ,  " r " );
     int  row, col, num;


     if ( ! feof(fp))  {
        fscanf(fp,  " %d " ,  & row);
        fscanf(fp,  " %d " ,  & col);
        fscanf(fp,  " %d " ,  & num);    
    } // if

     while ( ! feof(fp))  {

    } // while

    fclose(fp);
    printf( " %d, %d, %d " , row, col, num);
    getch();
     return   0 ;
}



/**/ /////////////////////////////////////////////////// /
//  example 2
//  beginning------------------transpose!!!
/**/ /////////////////////////////////////////////////// //
#include  " stdafx.h "
#include  < stdio.h >
#include  < conio.h >
#include  < stdlib.h >

typedef  struct   {
     int  col;
     int  row;
     int  value;
}  term; 

void  transpose(term a[], term b[]);
void  printMatrix(term a[]);

int  _tmain( int  argc, _TCHAR *  argv[])
{
    term  * pterm;
    FILE  * fp;
    fp  =  fopen( " h.txt " ,  " r " );

     int  i  =   1 ;
     int  row, col, num;
     if ( ! feof(fp))  {
        fscanf(fp,  " %d " ,  & col);
        fscanf(fp,  " %d " ,  & row);
        fscanf(fp,  " %d " ,  & num);
    } // if

    pterm  =  (term  * )malloc( sizeof (term)  *  (num + 1 ));
    pterm[ 0 ].col  =  col;
    pterm[ 0 ].row  =  row;
    pterm[ 0 ].value  =  num;
     while ( ! feof(fp))  {
        fscanf(fp,  " %d " ,  & pterm[i].row);
        fscanf(fp,  " %d " ,  & pterm[i].col);
        fscanf(fp,  " %d " ,  & pterm[i].value);
        i ++ ;
    } // while
    fclose(fp);
    printf( " A:\n " );
    printMatrix(pterm);
    term  * ptermB  =  (term  * )malloc( sizeof (term)  *  (num + 1 ));
    transpose(pterm, ptermB);
    printf( " B:\n " );
    printMatrix(ptermB);

    getch();
    free(pterm);
    free(ptermB);
     return   0 ;
}

void  printMatrix(term a[])
{
     for ( int  i  =   0 ; i  <=  a[ 0 ].value; i ++ )  {
        printf( " (%d, %d) %d\n " , a[i].row, a[i].col, a[i].value);
    } // for
}

void  transpose(term a[], term b[])
{
     int  n, i, j, currentb;
    n  =  a[ 0 ].value;
    b[ 0 ].row  =  a[ 0 ].col;
    b[ 0 ].col  =  a[ 0 ].row;
    b[ 0 ].value  =  n;
     if (n  >   0 )  {
        currentb  =   1 ;
         for (i  =   0 ; i  <  a[ 0 ].col; i ++ )
             for (j  =   1 ; j  <=  n; j ++ )
                 if (a[j].col  ==  i)  {
                    b[currentb].row  =  a[j].col;
                    b[currentb].col  =  a[j].row;
                    b[currentb].value  =  a[j].value;
                    currentb ++ ;
                } // if
    } // if
}

/**/ ////////////////////////////// /
//  fastTranspose
/**/ /////////////////////////////////
#define  MAX_COL 101
void  fastTranspose(term a[], term b[])
{
     int  len[MAX_COL], beginning[MAX_COL];
     int  i, n, currenta, k;
    n  =  a[ 0 ].value;
    b[ 0 ].row  =  a[ 0 ].col;
    b[ 0 ].col  =  a[ 0 ].row;
    b[ 0 ].value  =  n;

     for (i  =   0 ; i  <  n ; i ++ )
        len[i]  =   0 ;
     for (i  =   1 ; i  <=  n; i ++ ) 
        len[a[i].col] ++ ;
    beginning[ 0 ]  =   1 ;
     for (i  =   0 ; i  <  n; i ++ )
        beginning[i + 1 ]  =  beginning[i]  +  len[i];
     for (currenta  =   1 ; currenta  <=  n; currenta ++ )  {
        k  =  beginning[a[currenta].col] ++ ;
        b[k].row  =  a[currenta].col;
        b[k].col  =  a[currenta].row;
        b[k].value  =  a[currenta].value;
    } // for
}

/**/ ///////////////////////////////////////
//   list define
/**/ /////////////////////////////////////// /
typedef  struct  listNode  * listPointer;
struct  listNode  {
     char  data[ 4 ];
    listPointer link;
} ;

#define  MALLOC(p, s)\
     if ( ! (p)  =  malloc(s))  { exit(EXIT_FAILURE); }

listPointer first  =  NULL;
MALLOC(first,  sizeof ( * first));
free(first);

/**/ //////////////////////// //
//  listxi.h
/**/ ////////////////////////////// //
#ifndef LISTXI_H
#define  LISTXI_H

typedef  struct  listNode  * listPointer;
struct  listNode  {
     char  data;
    listPointer link;
} ;



void  printList(listPointer first);
void  insert(listPointer  * first, listPointer x,  int  dat);
listPointer create2();
// listPointer insertFollow(listPointer *head, );


void  printList(listPointer first)
{
    printf( " The list contains:  " );
     while (first)  {
        printf( " %4d " , first -> data);
        first  =  first -> link;
    } // while
    printf( " \n " );
}
void  insert(listPointer  * first, listPointer x,  int  dat)
{
    listPointer temp;
    temp  =  (listPointer) malloc( sizeof ( * temp));
    temp -> data  =  dat;
     if ( * first)  {
        temp -> link  =  x -> link;
        x -> link  =  temp;
    } // if
     else   {
        temp -> link  =  NULL;
         * first  =  temp;
    } // else
}

listPointer create2()
{
     // create a linked list with two nodes
    listPointer first, second;
    first  =  (listPointer) malloc( sizeof ( * first));
    second  =  (listPointer) malloc( sizeof ( * second));
    second -> link  =  NULL;
    first -> link  =  second;
    first -> data  =   1 ;
    second -> data  =   2 ;
     return  first;
}

#endif


/**/ /////////////////////////////////////// //
//
/**/ //////////////////////////////////////////