typedef_结构体指针_动态分配_void*

#include<stdio.h>
#include<stdlib.h>

typedef struct student{
　　　　int age;
　　　　int sex;
}student1,*p;

void main(){

//typedef用法
　　　　struct student student;
　　　　//student student;  //结构体和结构体变量可以同名
　　　　//student1 student;     //student1 == struct student
　　　　student.age = 10;
　　　　student.sex = 1;
　　　　printf("%d\t%d\n",student.age,student.sex);

//由结构体指针p可实现链表、栈、队列和更加复杂抽象数据类型的实现
　　　　p p_stu;
　　　　p_stu = &student;
　　　　printf("%d\t%d\n",p_stu->age,p_stu->sex);

//动态分配malloc
　　　　const int INIT_SIZE = 10;
　　　　const int INCREATEMENT = 5;
　　　　struct student *p_malloc;
　　　　p_malloc = (struct student*)malloc(INIT_SIZE*sizeof(struct student));
　　　　if(p_malloc == NULL)
　　　　　　　　exit(-1);

//realloc动态添加
　　　　for(int i=0;i<20;i++){
　　　　if(i>=INIT_SIZE){
　　　　p_malloc = (struct student*)realloc(p_malloc,(INIT_SIZE+INCREATEMENT)*sizeof(struct student));
　　　　//分配成功判断
  }
  //初始化操作
　　　　scanf("%d%d",p_malloc->age,p_malloc->sex);
}

}

//附：栈和队列的进与出本质为添加与删除

void:无类型   void* :无类型指针
测试1：
float *p1;
int *p2;
p1 = p2;  //反向同理
结果：cannot convert from 'int *' to 'float *'
纠正：p1 = (float*)p2;
结论：在汇编语言中:mov eax,bx是错误的

测试2：
void *p1;
int *p2;
p2 = p1;
结果：错误

测试3：
void *p1;
int *p2;
p1 = p2;
结果：可以通过
结合测试2和测试3得出
结论：“无类型”可以包容“有类型”，而“有类型”则不能包容“无类型”。

测试4：
void *p1;
int *p2;
int a = 1;
p2 = &a;
p1 = p2;
printf("%d",*p1);
结果：无法通过
小测试：printf("%d",*p1);换成:printf("%d",p1);通过
结论：无类型指针包容其他所有类型指针，但无法指定具体类型，指针本身无类型，为四字节地址

测试5：
函数:test(int a,int b){return a+b},主函数调用test(2,3)会输出5
结论：函数没加返回类型不要总误认为为void类型

测试6：void* 作为子函数参数
#include<stdio.h>
#include<stdlib.h>

typedef struct student{
int age;
int sex;
}student,*p;

student* addstudent(void* stu){
p stu_fun;
stu_fun = (p)stu; //动态绑定  类似于java中Object转型
//测试
printf("stu_fun->age:%d\n",stu_fun->age); //②结果：10
((p)stu)->age = 20; //stu_fun与(p)stu指向同一空间
return stu_fun;
}

void main(){

p stu;
stu = (p)malloc(sizeof(student));
stu->age = 10;
stu->sex = 1;
printf("stu前:stu->age：%d\n",stu->age); //①结果：10

p stu1;
stu1 = addstudent(stu);
printf("stu1->age:%d\n",stu1->age);  //③结果：20
printf("stu后:stu->age:%d\n",stu->age); //④结果：20
}

测试7：void*作为函数返回类型

typedef struct Student
{
int num;
char *name;
}Student, *pStudent;

void * getValue(void * std)
{
pStudent  p = (pStudent)std;
p->name = "hjt";
p->num = 123;
return p;
}

int main(int argnum, char **argstr)
{
pStudent p ;//= (pStudent)malloc(sizeof(Student));
printf("%x\n",&(p->num));

p = (pStudent)getValue(p);

pStudent q = NULL;
q->name = "lasdjf";
q->num = 344;

char *pp;
pp = "alsdjf";

printf("num = %d\n", p->num);
printf("name = %s\n", p->name);

return 0;
}
结论：其他类型指针自动转为void*，故return p有效，变量接收void*函数需要强转
结论2：malloc函数作用不是分配空间，而是赋给结构体变量一个首地址

总结：void真正发挥的作用在于：
　　（1）对函数返回的限定；
　　（2）对函数参数的限定。