day 02 - new - plus

#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>
#include<string.h>
#include<stdlib.h>

//指针变量大小，数组的首地址是数组的第一个元素地址。*i=j，i=&j;
//int main()
//{
//	double x = 66.6;
//	double* p = &x;
//
//	//p = &x;//double是双浮点数是8字节，一个字节是8bit，一个字节是一个地址，p里存一个地址，而那个地址是首地址或者低地址，因为大端和小端的问题
//
//	double arr[3] = { 1.1,2.2,3.3 };
//	double* q;
//	double* y;
//	q = arr;//数组第一个元素是首元素，首元素代表整个数组的地址，指针变量大小在32位机器中是4字节，64位机器是8字节,指针指向的是首元素的地址(不管那个数有多大)
//	printf("%p\n", q);
//	y = &arr[1];
//	printf("%p\n", y);
//
//	return 0;
//}

//传值与传址
// void f(int* x)
//{
//	*x = 20;
//}
//int main()
//{
//	int i = 10;
//	f(&i);
//	printf("%d\n", i);
//
//	return 0;
//}

//修改指针变量的值
//void f(int** x)
//{
//	*x = (int*)0x11223344;
//}
//int main()
//{
//	int i = 9;
//	int* p = &i;//int* p; p = &i; (&i = 9,为什么不给指针直接赋值呢，因为指针是指向一块空间的地址，不能赋值)
//	//p是指向i的地址(&是地址的意思)，访问p的时候是访问指针p,而非i,访问i要对p进行解引用，所以是*p = i,而i = 9,最后*p = 9;
//	printf("%p\n", p);
//	f(&p);//修改指针变量的值
//	printf("%p\n", p);
//
//	return 0;
//}

//结构体
//typedef struct student//struct student类型
//{
//	//成员
//	int sid;//成员变量
//	char name[200];
//	int age;
//}student;//分号不能省略
//
//int main()
//{
//	student st = { 1000,"张三",20 };
//	printf("%d,%s,%d\n", st.sid, st.name, st.age);
//	//那这样写行吗
//	st.sid = 99;
//	//st.name = "李四";//err
//	strcpy(st.name, "李四");//strcpy是拷贝的意思
//	st.age = 22;
//	printf("%d,%s,%d", st.sid, st.name, st.age);
//
//	//一般都不是用上面的形式定义结构体，都是用指针定义。因为如果要修改结构体时，用上面的就必须把值传进去，如果这个值太大，会拖垮整个程序。而指针传址过去就行了
//	student* pst;
//	pst = &st;
//	pst->sid;//pst->sid等价于*(pst).sid,而*(pst).sid等价于st.sid，所以pst->sid等价于st.sid 
//
//	return 0;
//}

//结构体2
//typedef struct student//struct student类型
//{
//	//成员
//	int sid;//成员变量
//	char name[200];
//	int age;
//}student;//分号不能省略
//
//void f();
//void g();
//void g2();
//int main()
//{
//	student st;//有空间，但是没有数据，严谨点说是有值是随机值，因为申请空间了。
//	f(&st);//这里就是等于pst=&st。理解：st这个地址发放给了pst这个指针变量，这个是加了数据
//	//g(st);//传值，因为可以相互赋值，所以传过去是现结构体的总大小。所以传值速度慢，还浪费空间。
//	g2(&st);//传址,只传过去指针的大小
//	//printf("%d,%s,%d\n", st.sid, st.name, st.age);
//	return 0;
//}
//
//这种方式耗内存，还有时间
//void g(student a)
//{
//	printf("%d,%s,%d\n", a.sid, a.name, a.age);
//
//}
//
//void g2(student *pst)
//{
//	printf("%d,%s,%d\n", pst->sid, pst->name, pst->age);
//
//}
//
//void f(student* pst)
//{
//	(*pst).sid = 99;//这里是pst解引用了，解引用之后就等于st了
//	strcpy(pst->name, "张三");
//	pst->age = 22;
//}

//静态数组(普通数组)||动态数组(增长的数组)
//int main()
//{
//	int a[5] = { 4,10,2,8,6 };//静态数组，这个5数是死的不能改
//
//	//动态内存
//	int len;
//	printf("请输入需要分配的数组长度：len =");
//	scanf("%d", &len);
//	int* parr = (int*)malloc(sizeof(int) * len);//sizeof(int)增加的类型的长度，* len是增加多少个。malloc请求系统分配空间(字节)，默认返回第一个字节地址，因为你知道第一个字节地址，能知道后面的占多少字节不，很困难。
//	//如果不强制转换，那不管什么类型(除了char类型)增加空间(字节)，第一个字节没有实际含义，所以没有意义，这种叫干地址。所以要强制转换类型
//	//因为：如果是int类型，它是4字节,要返回4个字节，但是malloc是返回第一个字节。如果double类型，它是8字节，要返回8个字节，但是malloc还是返回第一个字节，如果不初始化他都是以第一个字节表示，所以没有意义
//	//又因为* parr是个指针，它指向的是增加空间的首元素的地址。所以为什么说 指针指向数组的时候不需要数组加&(取地址符号了)
//	//*parr = 1;//这里让首元素称为1，类似于a[0] = 4,数组首元素地址
//	//parr[1] = 2;//这里让第二个元素为2，类似于a[1] = 10
//	//printf("%d,%d,%d", *parr, parr[1],parr[2]);//malloc是不会给你初始化的
//	
//	//我们可以把parr当作一个普通数组来使用
//	for (int i = 0; i < len; i++)
//	{
//		scanf("%d", &parr[i]);//每一个数初始化
//	}
//	for (int i = 0; i < len; i++)
//	{
//		printf("%d\n", *(parr + i));//每一个数打印
//	}
//
//	free(parr);//释放，还给操作系统
//
//	return 0;
//}

//跨函数使用内存的问题
//int f();
//int main()
//{
//	int i = 10;
//	i = f();
//	printf("i=%d\n", i);
//	return 0;
//}
//int f()//这个函数调用完之后这个空间就没了，你想想只分配不释放，内存终有一天会满的，但是这个只属于局部变量。动态变量
//{
//	int j = 20;
//	return j;
//}

//跨函数使用内存2
typedef struct student
{
	int sid;
	int age;
}student;
student* CreateStudent();//因为要创建动态数组，所以返回值要写传给ps,可以不需要形参
void ShowStadent(student* pst);//因为是输出一个结果，所以不需要返回值，但必须要形参
int main()
{
	student* ps;
	ps = CreateStudent();//这里简略看一下，意思是创建动态数组
	ShowStadent(ps);//向显示器输出一个结果
	return 0;
}

student* CreateStudent()
{
	student* p = (student*)malloc(sizeof(student));
	p->sid = 100;
	p->age = 23;
	return p;
}

void ShowStadent(student* pst)
{
	printf("%d,%d\n", pst->sid,pst->age);
}