1. Estructura
1.1 Concepto básico de estructura
La estructura pertenece al usuario.tipo de datos personalizado, lo que permite a los usuarios almacenar diferentes tipos de datos
1.2 Definición y uso de la estructura
gramática: struct 结构体名 { 结构体成员列表 }；
Hay tres formas de crear variables a través de estructuras:
- struct nombre de estructura nombre de variable
- struct nombre de la estructura nombre de la variable = { valor del miembro 1, valor del miembro 2...}
- Crear variables por cierto al definir la estructura.
Ejemplo:
#include<iostream>
#include<string>
using namespace std;
//结构体定义
struct student
{
//成员列表
string name; //姓名
int age; //年龄
int score; //分数
}stu3; //结构体变量创建方式3
int main() {
//结构体变量创建方式1
struct student stu1; //struct 关键字可以省略
stu1.name = "张三";
stu1.age = 18;
stu1.score = 100;
cout << "姓名：" << stu1.name << " 年龄：" << stu1.age << " 分数：" << stu1.score << endl;
//结构体变量创建方式2
struct student stu2 = {
"李四",19,60 };
cout << "姓名：" << stu2.name << " 年龄：" << stu2.age << " 分数：" << stu2.score << endl;
stu3.name = "王五";
stu3.age = 18;
stu3.score = 80;
cout << "姓名：" << stu3.name << " 年龄：" << stu3.age << " 分数：" << stu3.score << endl;
return 0;
}
Resumen 1: la palabra clave al definir una estructura es struct, que no se puede omitir
Resumen 2: al crear una variable de estructura, se puede omitir la palabra clave struct
Resumen 3: una variable de estructura utiliza el operador ''.'' para acceder a los miembros
1.3 Matriz de estructura
Función: coloque la estructura personalizada en la matriz para facilitar el mantenimiento
gramática: struct 结构体名 数组名[元素个数] = { {} , {} , ... {} }
Ejemplo:
#include<iostream>
#include<string>
using namespace std;
//结构体定义
struct student
{
//成员列表
string name; //姓名
int age; //年龄
int score; //分数
}
int main() {
//结构体数组
struct student arr[3]=
{
{
"张三",18,80 },
{
"李四",19,60 },
{
"王五",20,70 }
};
for (int i = 0; i < 3; i++)
{
cout << "姓名：" << arr[i].name << " 年龄：" << arr[i].age << " 分数：" << arr[i].score << endl;
}
system("pause");
return 0;
}
1.4 Puntero de estructura
Función: acceda a los miembros de la estructura a través del puntero y use el operador -> para acceder a las propiedades de la estructura a través del puntero de la estructura
Ejemplo:
#include<iostream>
#include<string>
using namespace std;
//结构体定义
struct student
{
//成员列表
string name; //姓名
int age; //年龄
int score; //分数
};
int main() {
struct student stu = {
"张三",18,100, };
struct student * p = &stu;
p->score = 80; //指针通过 -> 操作符可以访问成员
cout << "姓名：" << p->name << " 年龄：" << p->age << " 分数：" << p->score << endl;
return 0;
}
Resumen: el puntero de estructura puede acceder a los miembros de la estructura a través del operador ->
1.5 Estructura Estructura anidada
Rol: Un miembro de una estructura puede ser otra estructura
Por ejemplo: cada docente tutoriza a un alumno, y en la estructura de un docente, registrar la estructura de un alumno
Ejemplo:
#include<iostream>
#include<string>
using namespace std;
//学生结构体定义
struct student
{
//成员列表
string name; //姓名
int age; //年龄
int score; //分数
};
//教师结构体定义
struct teacher
{
//成员列表
int id; //职工编号
string name; //教师姓名
int age; //教师年龄
struct student stu; //子结构体 学生
};
int main() {
struct teacher t1;
t1.id = 10000;
t1.name = "老王";
t1.age = 40;
t1.stu.name = "张三";
t1.stu.age = 18;
t1.stu.score = 100;
cout << "教师 职工编号： " << t1.id << " 姓名： " << t1.name << " 年龄： " << t1.age << endl;
cout << "辅导学员 姓名： " << t1.stu.name << " 年龄：" << t1.stu.age << " 考试分数： " << t1.stu.score << endl;
return 0;
}
Resumen: En una estructura, se puede definir otra estructura como miembro para resolver problemas prácticos
1.6 Estructura como parámetro de función
Rol: pasar la estructura como parámetro a la función
Hay dos métodos de entrega: 值传递,地址传递
Ejemplo:
#include<iostream>
#include<string>
using namespace std;
//学生结构体定义
struct student
{
//成员列表
string name; //姓名
int age; //年龄
int score; //分数
};
//值传递
void printStudent(student stu )
{
stu.age = 28;
cout << "子函数中 姓名：" << stu.name << " 年龄： " << stu.age << " 分数：" << stu.score << endl;
}
//地址传递
void printStudent2(student *stu)
{
stu->age = 28;
cout << "子函数中 姓名：" << stu->name << " 年龄： " << stu->age << " 分数：" << stu->score << endl;
}
int main() {
student stu = {
"张三",18,100};
//值传递
printStudent(stu);
cout << "主函数中 姓名：" << stu.name << " 年龄： " << stu.age << " 分数：" << stu.score << endl;
cout << endl;
//地址传递
printStudent2(&stu);
cout << "主函数中 姓名：" << stu.name << " 年龄： " << stu.age << " 分数：" << stu.score << endl;
return 0;
}
Resumen: si no desea modificar los datos en la función principal, páselo por valor, de lo contrario, páselo por dirección
1.7 Escenarios de uso de const en estructuras
Función: use const para evitar un mal funcionamiento
Ejemplo:
#include<iostream>
#include<string>
using namespace std;
//学生结构体定义
struct student
{
//成员列表
string name; //姓名
int age; //年龄
int score; //分数
};
//const使用场景
void printStudent(const student *stu) //加const防止函数体中的误操作
{
//stu->age = 100; //操作失败，因为加了const修饰
cout << "姓名：" << stu->name << " 年龄：" << stu->age << " 分数：" << stu->score << endl;
}
int main() {
student stu = {
"张三",18,100 };
printStudent(&stu);
return 0;
}
1.8 Caso de estructura
1.8.1 Caso 1
Descripción del caso:
La escuela está haciendo un proyecto de graduación. Cada maestro dirige a 5 estudiantes, y hay 3 maestros en total. Los requisitos son los siguientes:
- Diseñe la estructura de estudiantes y maestros, donde en la estructura de maestros, hay nombres de maestros y una matriz que almacena 5 estudiantes como miembros;
- Los miembros de los estudiantes tienen nombres y puntajes de exámenes, crean una matriz para almacenar 3 maestros y asignan valores a cada maestro y los estudiantes que traen a través de la función
- Finalmente, se imprimen los datos del profesor y los datos del alumno traídos por el profesor.
Ejemplo:
#include<iostream>
#include<string>
#include<ctime>
using namespace std;
struct Student
{
string name;
int score;
};
struct Teacher
{
string name;
Student sArray[5];
};
void allocateSpace(Teacher tArray[] , int len)
{
string tName = "教师";
string sName = "学生";
string nameSeed = "ABCDE";
for (int i = 0; i < len; i++)
{
tArray[i].name = tName + nameSeed[i];
for (int j = 0; j < 5; j++)
{
tArray[i].sArray[j].name = sName + nameSeed[j];
tArray[i].sArray[j].score = rand() % 61 + 40;
}
}
}
void printTeachers(Teacher tArray[], int len)
{
for (int i = 0; i < len; i++)
{
cout << tArray[i].name << endl;
for (int j = 0; j < 5; j++)
{
cout << "\t姓名：" << tArray[i].sArray[j].name << " 分数：" << tArray[i].sArray[j].score << endl;
}
}
}
int main() {
srand((unsigned int)time(NULL)); //随机数种子 头文件 #include <ctime>
Teacher tArray[3]; //老师数组
int len = sizeof(tArray) / sizeof(Teacher);
allocateSpace(tArray, len); //创建数据
printTeachers(tArray, len); //打印数据
return 0;
}
1.8.2 Caso 2
Descripción del caso:
Diseñe una estructura de héroes, incluidos los nombres de los miembros, edades y géneros; cree una matriz de estructuras y almacene 5 héroes en la matriz.
A través del algoritmo de clasificación de burbujas, ordene los héroes en la matriz en orden ascendente según la edad y finalmente imprima los resultados ordenados.
La información de los cinco héroes es la siguiente:
{"刘备",23,"男"},
{"关羽",22,"男"},
{"张飞",20,"男"},
{"赵云",21,"男"},
{"貂蝉",19,"女"},
Ejemplo:
#include<iostream>
#include<string>
using namespace std;
//英雄结构体
struct hero
{
string name;
int age;
string sex;
};
//冒泡排序
void bubbleSort(hero arr[] , int len)
{
for (int i = 0; i < len - 1; i++)
{
for (int j = 0; j < len - 1 - i; j++)
{
if (arr[j].age > arr[j + 1].age)
{
hero temp = arr[j];
arr[j] = arr[j + 1];
arr[j + 1] = temp;
}
}
}
}
//打印数组
void printHeros(hero arr[], int len)
{
for (int i = 0; i < len; i++)
{
cout << "姓名： " << arr[i].name << " 性别： " << arr[i].sex << " 年龄： " << arr[i].age << endl;
}
}
int main() {
struct hero arr[5] =
{
{
"刘备",23,"男"},
{
"关羽",22,"男"},
{
"张飞",20,"男"},
{
"赵云",21,"男"},
{
"貂蝉",19,"女"},
};
int len = sizeof(arr) / sizeof(hero); //获取数组元素个数
bubbleSort(arr, len); //排序
printHeros(arr, len); //打印
system("pause");
return 0;
}
2. Unión
Unión es unión , que es una clase especial. Definida por la palabra clave unión, una unión puede tener varios miembros de datos. Por ejemplo
union Token{
char cval;
int ival;
double dval;
};
El código anterior define una unión denominada Token, que contiene 3 miembros de datos.
2.1 Ventajas de la Unión
Las ventajas de la unión son las siguientes:
1. Uso en segmentos
2. Ahorro de espacio: Para varias variables que no aparecen al mismo tiempo en un determinado periodo de tiempo, podemos ahorrar espacio de memoria mediante el uso de uniones.
3. En lugar de una fuerte conversión de tipo. Por ejemplo:En la programación de redes, a menudo se usa para pasar una cadena de datos, que se pasarán a diferentes funciones en forma de parámetros. Por lo tanto, se puede usar una unión, de modo que la unión esté llena de punteros de función, que apunten a diferentes funciones al mismo tiempo. Por lo tanto, se mejora la eficiencia de la programación y se ahorra espacio.
2.2 Limitaciones de unión
Los miembros de objeto en la unión no pueden tener constructores, destructores y operadores de asignación de copia sobrecargados; los miembros de objeto de los miembros de objeto no pueden tenerlos, y así sucesivamente,
la unión no puede heredar
2.3 caso de unión
Utilice la unión para guardar la información de calificación y la salida
#include <iostream>
using namespace std;
class ExamInfo {
public:
ExamInfo(string n, char g):name(n),mode(GRADE),grade(g){
}
ExamInfo(string n, bool p):name(n),mode(PASS),grade(p){
}
ExamInfo(string n, int p):name(n),mode(PERCENTAGE),grade(p){
}
void show();
private:
string name;
enum {
GRADE, PASS, PERCENTAGE} mode;
union {
char grade;
bool pass;
int percent;
};
};
void ExamInfo::show() {
cout << name << ": ";
switch(mode) {
case GRADE: cout << grade;break;
case PASS: cout << pass ? "PASS" : "FAIL";break;
case PERCENTAGE: cout << percent;break;
}
cout << endl;
}
int main() {
ExamInfo examInfo1("English", 'B');
ExamInfo examInfo2("Calculus", true);
ExamInfo examInfo3("C++ Programming", 85);
examInfo1.show(); // English: B
examInfo2.show(); // Calculus: 1
examInfo3.show(); // C++ Programming: 85
return 0;
}