并非从0开始的c++ day8

结构体

结构体嵌套二级指针练习

需求：一个老师数组，老师设计一个结构体，需要有老师的名字和一个学生数组，学生数组可以有若干个学生

//结构体设计
struct Teacher
{
	//老师姓名
	char* name;

	//老师带的学生姓名数组
	char** students;
};

void allocateSpace(struct Teacher *** teacherArray)
{
	if (teacherArray == NULL)
	{
		return;
	}
	//堆区分配内存
	struct Teacher** ts = malloc(sizeof(struct Teacher*) * 3);

	//数据赋值
	//给老师分配内存
	for (int i = 0; i < 3; i++)
	{
		//给老师分配内存
		ts[i] = malloc(sizeof(struct Teacher));

		//给老师姓名属性 分配内存
		ts[i]->name = malloc(sizeof(char) * 64);

		//给老师姓名赋值
		sprintf(ts[i]->name, "Teacher_%d", i+1);
		

		//给老师带领学生数组分配内存
		ts[i]->students = malloc(sizeof(char*) * 4);

		//给学生姓名分配内存 并且赋值
		for (int j = 0; j < 4; j++)
		{
			ts[i]->students[j] = malloc(sizeof(char) * 64);

			sprintf(ts[i]->students[j], "%s_student_%d", ts[i]->name, j+1);
		}
	}

	//建立关系
	*teacherArray = ts;
}

//打印操作
void printTeacherArray(struct Teacher ** teacherArray)
{
	for (int i = 0; i < 3; i++)
	{
		//老师姓名
		printf("%s\n", teacherArray[i]->name);

		for(int j = 0;j<4;j++)
		//老师带领的学生
		printf("	%s\n", teacherArray[i]->students[j]);
	}
}

//释放堆区数据
void freeSpace(struct Teacher** teacherArray)
{
	if (teacherArray == NULL)
	{
		return;
	}
	
	for (int i = 0; i < 3; i++)
	{
		//释放老师姓名
		if (teacherArray[i]->name != NULL)
		{
			free(teacherArray[i]->name);
			teacherArray[i]->name = NULL;
		}

		//释放学生姓名
		for (int j = 0; j < 4; j++)
		{
			if (teacherArray[i]->students[j] != NULL)
			{
				free(teacherArray[i]->students[j]);
				teacherArray[i]->students[j] = NULL;
			}
		}
		//释放学生数组
		free(teacherArray[i]->students);
		teacherArray[i]->students = NULL;

		//释放老师
		free(teacherArray[i]);
		teacherArray[i] = NULL;
	}

	//释放老师数组
	free(teacherArray);
	teacherArray = NULL;
}

void test01()
{
	//老师数组创建
	struct Teacher** teacherArray = NULL;

	//分配内存
	allocateSpace(&teacherArray);

	//打印所有老师和学生信息
	printTeacherArray(teacherArray);

	//释放堆区数据
	freeSpace(teacherArray);
	teacherArray = NULL;
}

牢记几个malloc对应几个free

结构体偏移量

printf(“b的偏移量：%d\n”, (int)&(p->b) - (int)p);
printf(“b的偏移量: %d\n”, offsetof(struct teacher, b));

struct  teacher
{
	char a;  //0 ~ 3
	int b;	 //4 ~ 7

};

void test01() 
{
	struct teacher t1;
	struct teacher* p = &t1;

	printf("b的偏移量：%d\n", (int)&(p->b) - (int)p);

	printf("b的偏移量: %d\n", offsetof(struct teacher, b));
}

通过偏移量获取数

void test02()
{
	struct teacher t1 = {'a',1000};
	struct teacher* p = &t1;

	printf("b的值为: %d\n", *(int*)((char*)p + offsetof(struct teacher, b)));
	printf("b的值为: %d\n", ((struct teacher *)((int*)p + 1))-> b);
}

//结构体2
struct teacher2
{
	char a;
	int b;


	struct teacher c;
};

void test03()
{
	struct teacher2  t = { 'a',10,'b',20 };

	int offset1 = offsetof(struct teacher2, c);
	int offset2 = offsetof(struct teacher, b);



	printf("属性c中的值为: %d\n", *(int *)((char*)&t + offset1 + offset2));

	printf("属性c中的值为: %d\n", *(int*)((char*)&t + offset1 + offset2));

	
}

内存对齐

访问特定类型的变量只能在特定的地址访问，这就需要各个变量在空间上按一定的规则排列，而不是简单地顺序排列，这就是内存对齐

内存对齐的原因

我们知道内存的最小单元是一个字节，当CPU从内存中读取数据的时候，是一个一个字节读取

实际上cpu将内存当成多个块，每次从内存中读取一个块，这个块的大小可能是2、4、8、16等

内存对齐是操作系统为了提高访问内存的策略。操作系统在访问内存的时候，每次读取一定长度（这个长度是操作系统默认的对齐数，或者默认对齐数的整数倍）。如果没有对齐，为了访问一个变量可能产生二次访问

内存对齐优点：以空间换时间

如何内存对齐

• 对于标准数据类型，它的地址只要是他的长度的整数倍
• 对于非标准数据类型，比如结构体，要遵循一下对齐原则

内存对齐原则
第一个属性开始 从0开始计算偏移量
第二个属性 要放在该属性的大小 与 对齐模数比 取小的值的 整数倍上
当所有属性都计算完毕之后，整体做二次偏移，将上面计算的结构体
将上面计算的结果 扩充到 这个结构体中最大数据类型的整数倍 与对齐模数比 取小的值 的整数倍
对齐模数默认为8

#pragma pack (show)//查看对齐模数的值 默认为8
#pragma pack (1)

typedef struct _STUDENT {
	int a;	// 0 ~ 3	//0~3
	char b; //4 ~ 7		//4
	double c;//8 ~ 15	//5~12
	float d;// 16 ~ 23	//13~16
}Student;

void test01()
{
	printf("student sizeof = %d\n", sizeof(Student));
}

当嵌套结构体时，以子结构体最大数据类型的整数倍来取地址即可

typedef struct _STUDENT2 {
	char a;		//0 ~ 7
	Student b;	//8 ~ 31
	double c;	//32 ~ 39
}Student2;

void test02()
{
	printf("student sizeof = %d\n", sizeof(Student2));
}

文件操作

文件的概念

通过fopen打开文件，中间还有一步open系统函数，open系统函数获取文件后，返回文件的指针FILE*给fopen

流的概念

C语言中，I/O操作可以简单地看做从程序移进或移出字节，这种搬运的过程称为流。I/O都是相对于程序来说，所以o输出为将字节输出到文件里，I输入为从文件读取

文本流

二进制流

我们程序中，经常看到的文本方式打开文件和二进制打开文件仅仅体现在换行符的处理上

输入/输出函数家族

家族名 目的 可用于所有流 只用于stdin和stdout
getchar 字符输入 fgetc、getc getchar
putchar 字符输出 fputc、putc putchar
gets 文本行输入 fgets gets
puts 文本行输出 fputs puts
scanf 格式化输入 fscanf scanf
printf 格式化输出 fprintf pirntf

文件缓冲区

有了缓冲区：提高硬盘寿命、提高运行效率

写文件时需要写fclose，因为可能有些数据留在写文件缓冲区，要是直接结束，可能会留这部分数据在里面没写进去，需要我们手动将其输出到文件

文件打开关闭

“r” 读
“w”写
“a”追加
“rb”二进制只读
“wb”二进制只写
“ab”二进制追加
“r+”允许读和写，文件必须已存在
“w+”允许读和写，如果文件不存在则创建，已存在则把文件长度截断为0字节再重新写
“a+”允许读和追加数据，如果文件不存在则创建
“rb+”以读或写方式打开一个二进制文件
“wb+”以读或写方式建立一个新的二进制文件
“ab+”以读或写方式打开一个二进制文件进行追加

文件关闭fclose

对打开文件进行写入时，若文件缓冲区的空间未被写入的内容填满，这些内容弄不会写到打开的文件中。只有对打开的文件进行关闭操作时，停留在文件缓冲区的内容才能写到改文件中，从而使文件完整。再者一旦关闭了文件，该文件对应的FILE结构将被释放，从而使关闭的文件受到保护，因为这时对该文件的存取操作将不会进行。文件的关闭也意味着释放了该文件的缓冲区

文件读写函数回顾

• 按照字符读写文件：fgetc()，fputc()
• 按照行读写文件：fputs()，fgets()
• 按照块读写文件：fread()，fwrite()
• 按照格式化读写文件：fprintf()，fscanf()
• 按照随机位置读写文件：fseek()，ftell()，rewind()

while ((ch = fgetc(f_read)) != EOF)
判断是否是文件尾

//按字符方式读写
void test01()
{
	//写文件
	FILE * f_write = fopen("./test1.txt", "w+");
	
	if (f_write == NULL)
	{
		return;
	}
	
	char buf[] = "hello world";

	for (int i = 0; i < strlen(buf); i++)
	{
		fputc(buf[i], f_write);
	}

	fclose(f_write);

	//读文件
	FILE* f_read = fopen("./test1.txt", "r");

	if (f_read == NULL)
	{
		return;
	}
	char ch;
	while ((ch = fgetc(f_read)) != EOF)
	{
		printf("%c", ch);
	}
	printf("\n");

	fclose(f_read);
}

按格式化读写文件

//移动文件光标
void test05()
{
	//打开文件
	FILE* f_write = fopen("./test5.txt", "wb");
	if (f_write == NULL)
	{
		return;
	}

	struct Hero heros[4] =
	{
		{"geats",19},
		{"revice",20},
		{"saber",21},
		{"zero one",22}
	};

	for (int i = 0; i < 4; i++)
		//参数1 写入数据的地址  参数2 块大小  参数3 快个数  参数4 文件指针
		fwrite(&heros[i], sizeof(struct Hero), 1, f_write);

	//关闭文件
	fclose(f_write);


	//读文件
	FILE* f_read = fopen("./test5.txt", "rb");
	struct Hero temp;

	if (f_read == NULL)
	{
		perror("文件打开失败");//errno宏 全局变量
		return;
	}
	//移动文件光标
	//fseek(f_read, sizeof(struct Hero) , SEEK_SET);
	fseek(f_read, -(long)sizeof(struct Hero) * 2, SEEK_END);
	
	//将文件光标置首
	rewind(f_read);

	fread(&temp, sizeof(struct Hero), 1, f_read);

	printf("姓名: %s 年龄：%d\n", temp.name, temp.age);

	fclose(f_read);
}

//参数1 写入数据的地址 参数2 块大小 参数3 快个数 参数4 文件指针
fwrite(&heros[i], sizeof(struct Hero), 1, f_write);

//移动文件光标
//fseek(f_read, sizeof(struct Hero) , SEEK_SET);
fseek(f_read, -(long)sizeof(struct Hero) * 2, SEEK_END);
前者从前往后移，后者从后往前移，后者需要强制类型转换

//将文件光标置首
rewind(f_read);

  perror("文件打开失败");//errno宏 全局变量

对于每一个错误都会有一个相应的代码

文件读写注意事项

void test01()
{
	//按照字符读test文件

	FILE* file = fopen("test.txt", "r");

	if (file == NULL)
		return;

#if 0
	char  ch;
	while (!feof(file))
	{
		ch = fgetc(file);
		if (feof(file))
		{
			break;
		}
		printf("%c", ch);
	}
#endif

	char ch;
	while ((ch = fgetc(file)) != EOF)
	{
		printf("%c", ch);
	}
	fclose(file);
}

• EOF为结尾，在if内部的代码用feof有滞后性，在文件读取结束后，还会进一次循环后再退出，if下面的代码就可以解决

• 如果结构体中属性，创建在堆区，保存数据到文件中的时候，要将指针放入到文件中