Recientemente, un internauta me envió un mensaje privado y me pidió que publicara una entrada de blog sobre la estructura para explicar la estructura básica de la estructura. Sin embargo, dado que la estructura en sí puede estar relacionada con punteros y matrices, el blogger se está preparando para publicar una estructura de tres fases. La publicación del blog del cuerpo explica por separado la explicación de la estructura.
Sin más preámbulos, comencemos a aprender sobre la estructura. Requisito previo: Al aprender cualquier conocimiento nuevo, primero comprenda el concepto. Solo cuando tenga una comprensión correcta y suficiente del concepto, podrá utilizar la herramienta correspondiente (palabra clave) correctamente.
1. Definición de estructura
Una estructura es en realidad una estructura en la que la lista de miembros consta de varios miembros, y cada miembro es un componente de la estructura.
El formato de definición de la estructura: nombre de la estructura de la estructura {nombre de la propiedad;};
Comprensión: podemos entenderlo como una plantilla, pero al mismo tiempo, podemos considerarlo como un tipo personalizado, al igual que el tipo int, el tipo corto, el tipo char, las palabras clave que se deben usar. La clase (clase) que aprendimos más tarde es en realidad muy similar en estructura a la estructura (estructura).
Struct es una palabra clave, y el nombre de la estructura después de la estructura se establece artificialmente, y el nombre de la estructura se puede considerar como una plantilla, una plantilla con atributos.
Por ejemplo: queremos crear una plantilla de un animal, los atributos de este animal son: nombre, peso, edad, por lo
tanto: nuestro análisis de esta idea debería ser: ①crear la plantilla de animales, ②añadir atributos a esta plantilla.
El código se implementa así:
//创建动物结构体
struct Animal
{
//属性名
char name[10]; //名字
int weight; //体重
int age; //年龄
};
Obviamente, la estructura animal que creamos de esta manera se ajusta al formato de definición de la estructura: estructura nombre de la estructura {nombre de la propiedad;};
Dos, las variables de la estructura
¿Cuáles son las variables de la estructura? Como mencionamos anteriormente, para crear una estructura, usamos struct para crearla. El formato es: struct nombre de estructura {nombre de propiedad;};
pero después de crear esta estructura, podemos usar la estructura, que es la plantilla , Que es nuestro Animal anterior, podemos entender Animal como una palabra clave similar a int, short y char para usar. Podemos usar Animal para definir variables, y las variables definidas por Animal también tienen memoria.
Sin embargo, lo que necesitamos decir aquí es que Animal es una plantilla. Esta plantilla tiene sus propios atributos. Si un objeto se crea con una plantilla de este tipo con atributos, el objeto creado tendrá los mismos atributos.
En primer lugar, echemos un vistazo a varias formas de crear objetos en una estructura:
Dos (1) crean un objeto al crear una estructura
Formato:
estructura nombre de estructura
{ nombre de atributo;} nombre de variable 1, nombre de variable 2;
//创建动物结构体的同时创建结构体变量
struct Animal
{
//属性名
char name[10]; //名字
int weight; //体重
int age; //年龄
}Cat，Dog;//用Animal这个结构体创建了Cat，Dog这两个结构变量，这两个变量都拥有名字，体重，年龄这几个属性。
Dos (dos) crean el objeto después de crear la estructura
Formato: nombre de estructura nombre de variable de estructura;
#include<iostream>
using namespace std;
//第一步，创建动物结构体
struct Animal
{
//属性名
char name[10]; //名字
int weight; //体重
int age; //年龄
};
int main()
{
//第二步，创建完结构体后再用结构名去创建变量
Animal Cat; //用Animal这个结构体创建了Cat变量，Cat拥有Animal的所有属性
Animal Dog; //用Animal这个结构体创建了Dog变量，Dog拥有Animal的所有属性
return 0;
}
Dos (tres) Después de comprender cómo definir variables de estructura, echemos un vistazo a cómo usar variables para llamar las propiedades de las variables.
Formato: nombre de variable. Nombre de atributo
A través de este formato, podemos inicializar los atributos de la variable en consecuencia
Dos (4) Cuando se trata de inicialización, hay dos formas de inicializar variables de estructura: ① Inicialización directa (la inicialización se realiza cuando se definen las variables de estructura y el orden de inicialización de los miembros es el orden de declaración de atributos de estructura) ② Inicialización indirecta.
La inicialización directa es la misma que la siguiente:
el orden de declaración de atributos de la estructura en sí es: nombre [10]; peso; edad
Luego, cuando se inicializa directamente, el orden de asignación es el nombre, peso y edad. La asignación se realiza y la verificación de salida es exitosa. Se inicializan las propiedades de las variables.
Código como:
#include<iostream>
using namespace std;
//创建动物结构体
struct Animal
{
//属性名
char name[10]; //名字
int weight; //体重
int age; //年龄
};
int main()
{
Animal Cat = {
"猫",10,1}; //在创建结构变量的时候进行初始化，初始化顺序为结构体属性的声明顺序
Animal Dog = {
"狗",20,2}; //直接初始化，分别为名字，体重，年龄
cout <<"动物名字为："<< Cat.name << endl;
cout << "动物体重为：" << Cat.weight << endl;
cout << "动物年龄为：" << Cat.age << endl;
cout << "动物名字为：" << Dog.name << endl;
cout << "动物体重为：" << Dog.weight << endl;
cout << "动物年龄为：" << Dog.age << endl;
return 0;
}
Resultado de la operación:
La inicialización indirecta no consiste en inicializar cuando se define la variable, sino en llamar al atributo a través de la variable de estructura, asignando así el atributo.
#include<iostream>
using namespace std;
//创建动物结构体
struct Animal
{
//属性名
char name[10]; //名字
int weight; //体重
int age; //年龄
};
int main()
{
Animal Cat = {
"猫"}; //当然，我们可以只对变量的属性部分初始化，赋值的顺序仍然是结构属性声明的顺序。所以猫赋值给了字符数组name[10]
Animal Dog = {
"狗"}; //同理
//对结构变量的属性进行调用，并且对属性进行初始化---间接初始化
Cat.age = 2;
cout <<Cat.name<< "的年龄为：" << Cat.age << "岁" << endl;
Dog.weight = 30;
cout <<Dog.name<< "的体重为：" << Dog.weight << "千克" << endl;
return 0;
}
resultado de la operación:
Tres, miembros de la estructura
A través de una o dos secciones, aprendimos cómo crear una estructura, cómo usar la estructura para crear variables y cómo usar variables para llamar a sus propias propiedades relacionadas. Aquí presentamos el concepto de miembros de estructura.
Miembros de estructura: Los miembros de estructura incluyen propiedades de miembro y funciones de miembro (también llamados métodos de miembro o métodos de estructura).
Propiedades de miembro: las propiedades de miembro son lo que dijimos anteriormente, las propiedades propias de la estructura. Después de que la estructura define las variables, Las variables también tienen los atributos de esta estructura. De esta forma es posible realizar operaciones como la asignación y salida de atributos.
Función miembro: La función miembro es en realidad la función de la estructura, qué tipo de función puede realizar esta plantilla, o qué puede hacer el objeto creado por esta plantilla y qué función realiza. Esta es la función miembro.
Aún así, tomemos Animal como ejemplo. Como sabemos, la mayoría de los animales pueden comer y saltar, por lo que comer se puede usar como una función de estructura, por lo que podemos pensar en escribir la estructura correspondiente de esta manera. Una función. Por lo tanto, las variables creadas por la estructura también pueden tener las funciones de la estructura, de modo que la variable de estructura puede llamar a la función miembro correspondiente.
== Formato: variable de estructura. Nombre de la función (lista de parámetros formales) ==
Por ejemplo: el 
código es el siguiente:
#include<iostream>
using namespace std;
//创建动物结构体
struct Animal
{
//成员属性：
char name[10]; //名字
int weight; //体重
int age; //年龄
//成员方法：
void Eat()
{
cout<<name << "吃东西了" << endl;
}
void Jump()
{
cout <<name<< "跳跃了" << endl;
}
};
int main()
{
Animal Cat = {
"猫"}; //当然，我们可以只对变量的属性部分初始化，赋值的顺序仍然是结构属性声明的顺序。所以猫赋值给了字符数组name[10]
Animal Dog = {
"狗"}; //同理
//对结构变量的属性进行调用，并且对属性进行初始化---间接初始化
Cat.age = 2;
cout <<Cat.name<< "的年龄为：" << Cat.age << "岁" << endl;
Dog.weight = 30;
cout <<Dog.name<< "的体重为：" << Dog.weight << "千克" << endl;
//对结构体变量的函数进行调用，简称为：结构体变量执行了某功能。（或者调用了某函数）
Cat.Eat(); //猫调用了吃东西函数（或者猫调用了吃东西方法）
Cat.Jump(); //猫调用了跳跃函数（或者猫调用了跳跃方法）
Dog.Eat(); //狗调用了吃东西函数（或者狗调用了吃东西方法）
Dog.Jump(); //狗调用了跳跃函数（或者狗用了跳跃方法）
return 0;
}
Resultado de la operación:
En cuanto al aprendizaje de C ++, invitamos a todos a seguirme, comentar mis artículos, me gusta, marcar, seguirme para no perderse. Los internautas también pueden hablar conmigo sobre productos secos de C ++. El conocimiento de C ++ es mucho más que eso, lo analizaremos y explicaremos uno a uno. Si los internautas quieren que les explique, pueden comentar y dejar un mensaje, y haré todo lo posible para explicárselo a todos.
： ： ProMer_Wang
Enlace: https://blog.csdn.net/qq_43801020/article/details/107182468
Este artículo es el artículo original de ProMer_Wang, los derechos de autor pertenecen al autor, indique la fuente del texto original para la reimpresión, ¡bienvenido a reimprimir!