#include <stdio.h>

float g_var = 10.0f; //注意，这里定义为float型的

struct Test

{

    int x;

    int y;

};

void f(int i,int j)

{

    printf("i + j = %d\n",i + j);

}

int g(int x)

{

    return (int)(  * x + g_var); //在本文件中g_var以float型处理

}

#include <stdio.h>

#include <malloc.h>

//这里只是声明，告诉编译器该全局变量在外部的global.c文件己经存在！（注意，不是头文件)

extern int g_var;  //注意，这里声明为int。但外部定义为float型。在处理这个.c文件时，编译器会处g_var当成整型来处理，但实际上内存中是以float存储的！

                   //这里声明为int是为了说明，声明和定义是不同的！

struct Test; //在global.c文件中，对于结构体声明无须加extern。

int main()

{

    extern void f(int,int); //这里只是声明，相当于告诉编译器，这个函数在外部文件中己经存在。

    extern int g(int);

    struct Test* p = NULL; //这里合法的

    //这里是错误的，因为结构体是在外部定义的，虽然在编译global.c时编译器是知道这个结构体的大小的。

    //但由于文件是分别编译的，编译只会按本文件中定义的类型来编译。由于本文件中找不到他的定义。

    //所以也就无法知道该结构体实际的大小，因此会报错。这就是声明和定义的区别！

    //struct Test* p = (struct Test*)malloc(sizeof(struct Test));//编译器提示这是一个不完全的类型

    printf("p = %p\n", p);

    //g_var = 10;  //这里可以取消注释来观察g_var值的变化！

    printf("g_var = %d\n", g_var);//会把内存中浮点型的g_var当成int型来处理！

    f(, );

    printf("g(3) = %d\n",g()); //g()函数（在global.c中），把g_var当成float型处理。

    free(p);

    return ;

}

#include <stdio.h>

int func(int i, int j)

{

    printf("i = %d, j = %d\n",i, j);

    return ;

}

int f()

{

    printf("f() Call...\n");

    return ;

}

int g()

{

    printf("g() Call...\n");

    return ;

}

int main()

{

    int k = ;

    int a = ;

    func(k++,k++); //gcc、vc、bcc：2，1

    printf("k = %d\n", k); //

    a = f() * g(); //*两侧的操作数顺序也不是固定的，vc、gcc：f()先被调用，然后g()

    return ;

}

#include <stdio.h>

int main()

{

    int k = ;

    int a = ;

    k = k++ + k++;

    printf("k = %d\n", k); //vc:6 = 2 + 2 + 1 + 1

                           //gcc:5 = 2 + 3

    //&&是顺序点，先计算a--并更新a，所以a=0;根据短路原理后面

    //表达式不被判断，所以下面一行不被输出

    if(a-- && a)

    {

        printf("a = %d\n", a); //该行不被输出！

    }

    return ;

}

#include <stdio.h>

#include <stdarg.h>

//一般的求平均值函数

float average(int array[],int size)

{

    int i = ;

    float avr = ;

    for(i = ; i<size; i++)

    {

        avr += array[i];

    }

    return avr / size;

}

//利用可变参数函数来实现

float averageEx(int n, ...)

{

    int i = ;

    float sum = ;

    va_list args; //声明一个args指向，指向可变参数列表

    va_start(args, n); //将args指向第1个可变参数

    for(i=; i<n; i++)

    {

        sum += va_arg(args,int);

    } 

    va_end(args);

    return sum / n;

}

int main()

{

    int array[] = {, , , , };

    printf("%f\n", average(array,));

    printf("%f\n", averageEx(, ,,,,));

    printf("%f\n", averageEx(, ,,,));

    return ;

}

#include <stdio.h>

#define RESET(p,len)          \

     while( len > )          \

        ((char*)p)[--len] = 

void reset(void* p, int len)

{

    while(len > )

      ((char*)p)[--len] = ;

}

int main()

{

    int array[] = {, , , , };

    int len = sizeof(array);

    int i= ;

    for(i=; i<; i++)

    {

        printf("array[%d] = %d\n",i, array[i]);

    }

    RESET(array, len);

    //reset(array, len);

    for(i=; i<; i++)

    {

        printf("array[%d] = %d\n",i, array[i]);

    }

    return ;

}

#include <stdio.h>

#define _ADD_(a, b) a + b

#define _MUL_(a, b) a * b

#define _MIN_(a, b) ((a) < (b) ? (a) : (b))

int main()

{

    int i = ;

    int j = ;

    //本意要计算3 * 7

    printf("%d\n", _MUL_(_ADD_(, ), _ADD_(, )));//1 + 2 * 3 + 4  ==>11

    //本意要求min(1,10)

    printf("%d\n", _MIN_(i++, j)); //(i++)<(j) ? (i++):(b) //输出2

    return ;

}

#include <stdio.h>

#include <malloc.h>

#define MALLOC(type, x)  (type*)malloc(sizeof(type)*x)

#define FREE(p)          (free(p),p = NULL)

//输出格式：变量名 = 变量的值

#define LOG_INT(i)        printf("%s = %d\n", #i,  i)

#define LOG_CHAR(c)       printf("%s = %c\n", #c,  c)

#define LOG_FLOAT(f)      printf("%s = %f\n", #f,  f)

#define LOG_POINTER(p)    printf("%s = %p\n", #p,  p)

#define LOG_STRING(s)     printf("%s = %s\n", #s,  s)

//ForEach函数

#define FOREACH(i, n)    while(1){ int i = 0, l = n;for(i=0;i<l;i++)

#define BEGIN            {

#define END               }break;}

int main()

{

    int* pi = MALLOC(int,);//己定义好MALLOC的返回类型，无须再强制转换

    char* str = "Hello World!";

    LOG_STRING(str); //打印变量名及变量的值

    LOG_POINTER(pi);

    //k在宏内会被定义，其作用域在很小，此处无须再定义

    FOREACH(k, )

    BEGIN

        pi[k] = k + ;

    END

    //k在宏内会被定义，此处无须再定义

    FOREACH(k, )

    BEGIN

        int value = pi[k];

        LOG_INT(value);

    END

    FREE(pi);

    LOG_POINTER(pi);

    return ;

}