宏也可以传递参数
e.g #define N(n) n*10
int a=20;
int b= N(a);//
#define ADD(a,b) (a+b) int ADD(a,b); 
优势：不需要定义输入参数好返回值的类型
Plus: 预处理中还有条件编译的功能。

1.宏替换也出现在预处理中，且不管C的语法，单纯为字符串替换
2.声明宏用#define
3.宏的作用为声明反复出现的常量及数组的buffer
{e.g #define R 10(注意没有分号！)
int a = R；
int a[M], B[M];
或者#define R int main( ，然后输入M)也行}

编译一个程序分为四步骤：.c文件-(预处理)->.i文件-(编译)->.s文件-(汇编)->.o文件-(链接)->可执行文件
预处理 分为展开头文件(#include<stdio.h>)和宏替换
ps. ":s"的作用为跳到文件底部

按位或 换成1

.为成员运算符，优先级最高

define不遵从C语法，typedef遵从C语法

【预处理】.c——.i

【编译】.i——.s

【汇编】.s——.o

【链接】.o——可执行文件

vim helleword.c-->gcc helloword.c 编译的四个步骤（预处理，编译，汇编，链接）

malloc返回的是开辟空间的首地址，他并不知道你放的是什么类型的东西，所以要用第一个括号中的内容强制转换指针类型为struct weapon*,和p1的类型转为一样，否则会警告指针类型不符合

#include <stdio.h>

struct nam

{

    char *name[20];  //用指针

    int old;

    float height;

    struct nam * next;

};

int main()

{

    struct nam a,b, *head;

    a.name[0]="李";  //第一个地址

    a.old=16;

    a.height=70.2;

    b.name[0]="林";

    b.old=21;

    b.height=65.3;

    head=&a;

    a.next=&b;

    b.next=NULL;

    struct nam *w;

    w=head;

    while (w!=NULL){

        printf("姓名：%s\n年龄：%d\n身高：%f\n",w->name[0],w->old,w->height); //把地址取出来

        w=w->next;

    }

    return 0;

}

#include <stdio.h> typedef struct weapon{    // 这个地方这么定义    char *name;    int atk;    int price;}weapon_t; int main(){    weapon_t weapon1;         weapon1.name="tom";    weapon1.atk = 100;    weapon1.price = 200;    printf("%s %d %d\n",weapon1.name,weapon1.atk,weapon1.price);         return 0;}

静态数据结构：整型，浮点型，数组等，声明时要说明长度，且长度固定。

数组里的元素地址连续，

动态数据结构，如链表，空间不定；

head存有指向第一个元素的地址，每个元素都有内容及指向下元素的地址，尾元素地址为空；   没有头指针即head，整个链表都找不到；

静态链表： （以结构体类型作为节点元素为例）

struct weapon { int price; int atk; struct weapon * next; };
int main(){
    struct weapon a,b,c,*head;
    a.price=100; a.atk=100;
    b.price=200; b.atk=200;
    c.price=300; c.atk=300;
    head=&a;  a.next=&b; b.next=&c; c.next=NULL;
    //下面用指针逐个输出
    struct weapon *p; p=head;
    while(p!=NULL){
    printf("%d,%d\n",p->atk,p->price);
    p=p->next; //p指向下一节点的指针内容
    }
    return 0;
}

typedef 语法特性：

• 是一种语法，不是一种预处理；

• 存在作用域；

• 给自写的数据类型取个好看的类名；

• 简化结构体的声明语句。

共用体：让几个不同类型的变量共享一个地址即内存单元，节省空间，缺点是同一时刻只能存储一个变量成员；

union data{ int a;  int b;  char c;  float d; };
//声明一个共用体变量data；
初始化：
union data data_1;   data_1.a=10; data_b='Q';//现在真正起作用的是后一个被赋值的成员，即data_b;
也可以union data data_1={'Q'};//这里只能有'Q'一个常量；
共用体的内存长度是其最长成员的长度；

struct weapon * w；//声明一个指向struct weapon类型的指针变量

    w=&weapon_1;         //让w指向weapon_1

*w表示w指向的变量weapon_1;

(*w).name即是weapon_1.name,也可以w->name

struct weapon *p；  //声明一个指向struct weapon变量的指针

p=weapon_2;        //weapon_2是数组weapon_2[2];此处指向该数组的第一个也即weapon_2[0];

同样，也可以p->name或weapon_2[0].name;

若要指向第二个，p++；