结构体

结构体又称自定义数据类型

将信息打包存放在一起而不是分开存放。

关键字   Struct

Struct  Student   定义一个结构体，结构体名首字母尽量大写。

{

    char name[20];

    int  age;

};

int 三个基本操作

int a=10;                   定义一个普通变量；

int arr[10]={0};           定义一个数组;            聚合类型初始化一部分剩余为零（数组，结构体）

int *P=&a;                  定义指针变量； 

类似于int数据类型，自定义数据类型也有类似三种操作。

哪些数据类型能用在结构体内部：

1、基本数据类型；

2、前面已经定义的结构体（不允许使用不完整的类型 ，例如：自己使用自己）；

3、包含自身结构体定义的指针；

struct Student
{
	char name[20];
	int age;
};

struct A
{
	int a;  定义一个普通变量
	char b;
	short c;
	double *d; 定义一个指针
	struct Student e;   A之前定义的结构体（就是一个数据类型）
	//struct B f;//error  B在A之后定义的不能使用
	//struct A g;//error  不允许使用不完整类型（此时的A还没有定义完整）
	struct A *p;//ok    自身结构体定义的指针
	int i;
};

struct B
{
	int x;
	int y;
};

 

通过结构体访问结构体成员的方式：

1、结构体普通变量通过   "  .  "访问其成员

2、结构体指针变量通过   "  -> "(指向符)访问其成员

void Show(struct Student stu)
{
	printf("%s,%d\n",stu.name,stu.age);
}

void Show(struct Student *pstu)
{
	printf("%s,%d\n",(*pstu).name,(*pstu).age);
}
void Show(Student *pstu)
{
	printf("%s,%d\n",pstu->name,pstu->age);
}
int main()
{
	int a = 10;
	int *p = &a;
	int arr[10] = {0};

	struct Student stu1;
	struct Student stu2 = {"liubei"};//初始化一部分，则剩余部分为0
	stu2.age = 18;
	//如何给stu1中的name赋值
        //stu1.name = "caocao";//error  初始化才能赋值，不能直接给字符串fuzhi 
	strcpy(stu1.name,"caocao");//用字符串拷贝函数
	stu1.age = 20;
	
	//printf("%s,%d\n",stu1.name,stu1.age);输出stu1里的姓名和年龄
        //Show(stu1);也可以直接写成函数的形式

	struct Student *pstu = &stu1; 定义一个结构体类型的指针pstu存放stu1的地址
	(*pstu).age = 21;//对指针pstu解引用再访问age
	pstu->age = 22;//由于.的优先级比*高所以加括号，由于这样写不太方便，可以直接使用指向符
	Show(&stu1);

	return 0;
}

struct Student//设计
{
	int id;
	char name[20];
	int score;
	//int age;
	//int age = 18;//error不能在定义的时候直接初始化，只是定义了一个数据类型
};

int main()
{
	struct Student stu1,stu2;
	struct Student stu3;
	scanf("%d%s%d",&stu1.id,stu1.name,&stu1.score);
	scanf("%d%s%d",&stu2.id,stu2.name,&stu2.score);

	if(stu1.score > stu2.score)//输出分数高的学生信息
	{
		printf("%d,%s,%d\n",stu1.id,stu1.name,stu1.score);
	}
	else
	{
		printf("%d,%s,%d\n",stu2.id,stu2.name,stu2.score);
	}

	return 0;
}*/

typedef struct Student
{
	char name[20];
	int age;
}Student;//定义一个结构体并给他起一个别名Student 给新的数据类型起一个别名 等同下面的写法

//struct Student
//{
//	char name[20];
//	int age;
//};
//typedef struct Student Student; 先定义一个结构体再给他起别称

 

结构体内数据的访问
struct A
{
	int a;
	int *b;
};

struct B
{
	char c;
	struct A sd;
	int *e;
};

int main()
{
	struct B bb;
	struct B *pb = &bb;

	bb.c;
	bb.sd.a;
	bb.sd.b;
	bb.e;
	pb->c;
	pb->sd.a;
	pb->sd.b;
	pb->e;

	return 0;
}

？？？ 

void Show(Student *pstu)
{
	printf("%s,%d\n",pstu->name,pstu->age);
}

//输出结构体数组的内容
void Show(Student *arr,int len)
{
	for(int i=0;i<len;i++)
	{
		printf("%s,%d\n",arr[i].name,arr[i].age);
	}
}

int main()
{
	Student stu1 = {"liubei",20};
	Student *pstu = &stu1;
	Student arr[] = {{"liubei",19},{"caocao",20},"sunquan",18};
	arr[0].age = 23;

	Show(arr,sizeof(arr)/sizeof(arr[0]));//

	//Show(pstu);//?????Show(&stu1)

	return 0;
}

//3、typedef 类型定义
typedef unsigned long long int uint64;
typedef int* Pint;//加上typedef由变量变成数据类型
typedef int Arr[10];//整形数组这种数据类型
typedef int (*Pfun)(int,int);
#define PINT int*//只是字符替换

int Max(int a,int b)
{
	return a>b ? a : b;
}

int main()
{
	int a = 10;
	Pint c,d;
	PINT e,f;
	c = &a;
	d = &a;
	e = &a;
	//f = &a;//error//宏定义只是字符替换
	//unsigned long long int a = 100;
	//unsigned long long int b = 200;
	//uint64 c = 300;
	//uint64 d = 400;
	//Pint p1;//int *
	//Pint p2;//int *
	//Arr i;//
	//printf("%d\n",sizeof(i));
	//Pfun fun;
	

	return 0;
}
*/