交换函数定义

代码组成：语句188+166 ->表达式（逻辑，算数等）->代码块{}

C中允许{}代码块中定义变量，编译器是根据{}来做入栈出栈操作来管理变量的作用域的。而全局变量和静态变量的分布就不同。

1.交换函数

#include <stdio.h>
/*交换函数*/
#define SWAP(a,b)\
do{\
     typeof(a)  _tmp = (a);\
     (a) = (b);\
     (b) = _tmp;\
   }while(0)

/*指针 交换函数*/
void SWAP_2(float *a,float *b)
{
    float Tmp = 0;
    Tmp = *a;
    *a = *b;
    *b = Tmp;
}



int main(void)
{
    int a = 100;
   // int b = 99;
    float b = 99.8;
    SWAP(a,b);
    printf("a= %f: b = %f:",a,b);
    //printf("a= %f: b = %f:",&a,&b);
}

2.比较大小函数 

优点：typeof直接读取参数类型，无需使用宏进行单独传参。

(void) (&_x == &_y);   是为了对x,y的数据类型在编译中不同时候报警提示，进行指针类型比较如果不同一般会显示  

warning:comparison  of  distinct  pointer  types  lacks  a  cast1

/*比较大小函数升级,typeof关键字直接获取类型*/
#define Min(x,y)({\
     typeof(x) _x1 = (x);\
     typeof(y) _y1 = (y);\
     (void) (&_x1 == &_y1);\
     _x1 < _y1 ? _x1 : _y1;  \
})


#define Max(x,y)({\
     typeof(x) _x1 = (x);\
     typeof(y) _y1 = (y);\
     (void) (&_x1 == &_y1);\
     _x1 < _y1 ? _x1 : _y1;  \
})
//(void) (&_x == &_y);   是为了对x,y的数据类型在编译中报警提示取消，实现数据类型强转

3.变参函数

  不同于通常的实参和形参必须数量格式一直，变参函数顾名思义就是函数的参数不确定

/*变参函数的实现,*/
//指针地址方式
#include <stdio.h>
/*i<= count时候打印会出问题，因为超过了参数个数，内存会随机的显示一个数字*/
void  print_num(int count,...)
{
    int  *args;
    args = &count + 1;
    for( int i = 0;i<=count ;i++)
    {
     printf("*args:%d\n",*args);
     args++;
    }
}

int  main(void)
{
  print_num(5,1,2,3,4,5);
  return 0;
}

/*i<= count时候打印会出问题，因为超过了参数个数，内存会随机的显示一个数字*/

/*i<= count+1时候打印会出问题，因为超过了参数个数，内存会随机的显示一个数字*/

i < count  ,如下

#include <stdio.h>
/*交换函数，比较大小函数，平方*/

/*define 交换函数*/
#define SWAP(a,b)\
do{\
     typeof(a)  _tmp = (a);\
     (a) = (b);\
     (b) = _tmp;\
   }while(0)

/*指针 交换函数*/
void SWAP_2(float *a,float *b)
{
    float Tmp = 0;
    Tmp = *a;
    *a = *b;
    *b = Tmp;
}


/*比较大小函数升级,typeof关键字直接获取类型*/
#define Min(x,y)({\
     typeof(x) _x1 = (x);\
     typeof(y) _y1 = (y);\
     (void) (&_x1 == &_y1);\
     _x1 < _y1 ? _x1 : _y1;  \
})


#define Max(x,y)({\
     typeof(x) _x1 = (x);\
     typeof(y) _y1 = (y);\
     (void) (&_x1 == &_y1);\
     _x1 < _y1 ? _x1 : _y1;  \
})
//(void) (&_x == &_y);   是为了对x,y的数据类型在编译中报警提示取消，实现数据类型强转

/*求平方,a为参数，b为参数的次方*/
#define  Square(a,b)\
do{\
     typeof(a)  _tmp = (a);\
     (a) = (b);\
     (b) = _tmp;\
   }while(0)




/*指定数组初始化*/
int ArraX[100] = {[11] = 11  ,[12] = 12};
int ArraY[100] = {[10 ... 15] = 5,[16 ... 17] = 6};




int main(void)
{
    float a = 100; float c = 100; float b = 99.8; float d = 88.6;


    SWAP_2(&a,&b);
    Min(c,d);


    printf("a= %f b = %f\r\n",a,b);
    printf("Min=%f\r\n",Min(c,d));
    printf("ArraX_11 = %d,ArraX_12 = %d,ArraX_5 = %d\r\n",ArraX[11],ArraX[12],ArraX[5]);
    printf("ArraY_11 = %d,ArraY_12 = %d,ArraY_17 = %d\r\n",ArraY[11],ArraY[12],ArraY[17]);
    switch(ArraY[11])
    {
        case 1:
            printf("ArraY_11 = %d\r\n",ArraY[11]);
            break;

        case 2 ... 6:
            printf("ArraY_16 = %d\r\n",ArraY[16]);
            break;

        default:
        printf("default!\n");
        break;
    }
    /*表达式内部使用变量*/
    int sum = 0;
     int  m = 0;
    sum = ({
             for(   m = 0;m < 5;m++)  //GCC允许在一个表达式里内嵌语句，允许在表达式内部使用局部变量,C不行
                {
                    sum = m+1;
                }
                sum;
           });
           printf("sum = %d\r\n",sum);
    return 0;
}