武器信息的单向动态链表，在程序执行的过程中逐渐创建节点

struct weapon * create()//返回值是链表的头指针

{struct weapon * head;//头指针

struct weapon * p1,*p2;//链表当前新创建的节点，上一个节点

int n=0;//记录当前链表个数

p1=p2=(struct weapon *)malloc(sizeof(struct weapon));//#include<malloc.h>,malloc分配内存块，sizeof判断数据类型的长度符

head=null;//赋初值

scanf("%d,%d",&p1->price,&p1->atk);

while(p1->price!=0)

{

n++;

if(n==1)head=p1;

else p2->next = p1;//上一个节点的next指向创建的新节点

p2=p1;//创建完成之后更新旧节点

p1=(struct weapon *)malloc(sizeof(struct weapon));//更新p1

scanf("%d,%d",&p1->price,&p1->atk);

}

p2->next=null;

return (head);

}

struct weapon * p;

p=creat();//p是头指针，指向第一个节点

静态数据结构（固定大小）：整型，浮点型，数组，

动态数据结构：链表

每一个节点包含两个部分，一部分是用户需要的数据，一部分是下一个节点的地址

链表里各个元素的地址不连续

struct weapon{

int price;

int atk;

struct weapon *next;//下一个节点的信息

};

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){

p->atk,p->price;

p=p->next;

}

a.price=100;

a.atk=100;

共用体 联合体 几个不同的类型变量使用同一个内存地址，节省一定的开销，同一时刻只能存储一个成员

union data{

int a;

char b;

int c;

}

union data data_1;

data_1.b='c';

data_1.a=10;//起作用

union data data_2={10};

共用体所占的内存长度是它所有成员里所占内存最长的成员长度

int为4，char为1，union长度为4

结构体（字节对齐，快速读写，空间换取时间）所占内存长度是最后一个成员的偏移量加上最后一个成员的大小加上末尾的填充字节数

偏移量是某一个成员的实际地址和结构体首地址之间的距离

a偏移量为0，b偏移量为a的大小4

每个成员相对于结构体首地址的偏移量是当前成员所占内存大小的整数倍，如果不是则填充字节

c偏移量为a的大小4+b的大小1等于5不能整除c的大小4，所以在b后填充字节使c的偏移量为8

结构体大小为8+4=12

结构体总大小是不是结构体中内存长度最长的成员长度的整数倍，如果不是填充字节

12可以整除4，如果不能整除则在c后填充字节

%lu   sizeof(struct data)

共用体变量的地址和成员的地址是同一个

%p  &data_1.a

结构体指针

struct weapon *w;

w=&weapon_1;

(*w).name表示指向结构体中的成员（）不能省略，.的优先级大于*的优先级，w->name

*w表示指向结构体变量

结构体数组指针

struct weapon *p;

p=weapon_2;

p->name既是weapon_2[0].name

p++既是weapon_2+1，指向了weapon_2[1]

初始化结构体

struct weapon weapon_1={"weapon_name",100,200};

访问结构体成员,具有所有变量的操作

weapon_1.name

++weapon_1.price

结构体数组

int a[2]={1,2}

struct weapon weapon_2[2]={"weapon_name1",50,100,"weapon_name2",100,200}

struct weapon weapon_2[2]={{"weapon_name1",50,100},{"weapon_name2",100,200}}

weapon_2[0].name

weapon_2[1].price

struct 是不同变量类型的集合

数组是相同变量类型的集合

struct weapon{

char name[20];

int atk;

int price;

};
struct weapon weapon_1;

struct weapon{

char name[20];

int atk;

int price;

}weapon_1;//全局变量

struct {

char name[20];

int atk;

int price;

}weapon_1;//全局变量

预处理命令

define的作用域是宏定义下面的所有代码

typedef：关键字，给变量类型起别名，预处理之后不会被替换，有作用域

typedef int a;（以分号为结尾）

typedef int *p;（给int* 起别名叫p）

p q=NULL;//int *q=NULL;

结构体：

typedef unsigned long size_t

struct stu{};

stuct stu XXX;

typedef struct stu{}stu_t;

stu_t XXX;

#define N(n) n*10

int b=N(a);   //int b=a*10;

#define ADD(a,b) a+b

int b=ADD(a,b);   //int b=a+b;

int e=ADD(a,b)*ADD(a,b)//预处理int e=a+b*a+b->执行

#define ADD(a,b) （a+b）不要求类型

#define R 10(不要分号)

10作为一个字符串替换掉R

#define M int main(也可以执行，预处理不考虑语法

反复使用的常量，数组buffer（数组大小），便与修改

.c文件->预处理->.i文件->编译->.s文件->汇编->.o文件->链接->可执行文件

vim helloworld.c创建一个.c文件

gcc helloworld.c编译文件

gcc -o helloworld.i helloworld.c -E生成一个.i文件，只进行预处理

预处理：展开头文件，宏替换

共用体：共用体内的各元素分时占同一个地址上。

共用体内的数据存储的地址都是同一地址，每一时刻只能存储一个数据。共用体的存储地址长度是内部定义的最长数据类型的长度。而结构体的存储地址长度是内部各数据的长度的累加（注意：每个数据的偏移量必须是自身长度的整数倍，如果不是整数倍，则填充。如int，char，int，则最后的int的偏移量是int+char=5,则int前需要填充3个字节到8个字节，才为int的整数倍。如果总长度不是内部长度最大的整数倍，则最后一个的长度要填充）

typedef有作用域的问题

define没有作用域的问题

在预编译阶段 #define段会把内容替换 但typedef并不会

.i文件是进行预编译之后生成的文件，一般都是把头文件包含进去，进行宏替换这些工作之后生成的文件。