Explicación detallada de la estructura y enumeración de C++

---

prefacio

Si está interesado en aprender C++, puede leer este artículo: Tutorial de C/C++

estructura

1. El concepto de estructura (Struct)

1.1 ¿Qué es una estructura?

Una estructura es un tipo de datos definido por el usuario que puede combinar múltiples variables de diferentes tipos para formar un nuevo tipo de datos. Una estructura consta de varios atributos (es decir, variables miembro o campos), que pueden incluir variables de varios tipos de datos, como enteros, coma flotante, caracteres, etc.

1.2 Definición de estructura

En C++, podemos definir una estructura de las siguientes maneras:

struct Person {
    
    
    string name;
    int age;
    bool gender;
};

En este ejemplo, definimos una estructura llamada Persona. Esta estructura contiene tres atributos: nombre, edad y género. Entre ellos, el nombre es una variable miembro de tipo cadena, la edad es una variable miembro de tipo entero y el género es una variable miembro de tipo booleano.

2. Uso de la estructura

2.1 Inicialización de la estructura

Las estructuras se pueden inicializar de las siguientes maneras:

Person John = {
    
    "John", 30, true};

Esta es una variable definida como estructura de tipo Persona. La variable John representa a una persona, la cual contiene nombre, edad y género.

2.2 Estructuras como parámetros de función

Las estructuras se pueden usar como argumentos para las funciones, lo que facilita el paso de múltiples variables a una función.

void printPersonInfo(Person p){
    
    
    cout << "Name: " << p.name << endl;
    cout << "Age: " << p.age << endl;
    cout << "Gender: " << (p.gender ? "Male" : "Female") << endl;
}

En este ejemplo, definimos una función llamada printPersonInfo que toma un argumento de tipo Person. La función imprimirá el nombre, la edad y el sexo de la persona.

2.3 Estructuras como elementos de matriz

Las estructuras se pueden usar como elementos de matrices para formar un tipo de datos compuesto personalizado.

Person people[3] = {
    
    {
    
    "John", 30, true}, {
    
    "Alice", 25, false}, {
    
    "Bob", 35, true}};

En este ejemplo, definimos una matriz denominada personas que contiene tres elementos de tipo Persona. Cada elemento representa a una persona, incluido el nombre, la edad y el sexo.

2.4 Struct como variable miembro de una clase

Las estructuras también se pueden usar como variables miembro de clases para formar un tipo de datos más complejo.

class Student{
    
    
public:
    string name;
    int age;
    bool gender;
    Person teacher;
};

En este ejemplo, definimos una clase llamada Estudiante, que incluye cuatro variables miembro: nombre, edad, sexo y profesor. Entre ellas, profesor es una variable miembro de tipo Persona, que representa al profesor del alumno. De hecho, podemos definir clases más complejas de esta manera, mejorando así la legibilidad y la mantenibilidad del programa.

3. Precauciones para las estructuras

3.1 El problema de la estructura que ocupa la memoria

Al usar estructuras, debemos prestar atención al problema de la memoria ocupada por estructuras. Dado que una estructura puede contener varias variables miembro, a menudo ocupa mucho espacio. Si la estructura es demasiado compleja o contiene una gran cantidad de variables miembro, puede causar que la velocidad de ejecución del programa disminuya significativamente. Por lo tanto, al escribir un programa, necesitamos minimizar el tamaño de la estructura para mejorar la eficiencia operativa del programa.

3.2 Métodos de acceso de variables miembro de estructura

Se puede acceder a las variables miembro de la estructura de dos maneras, a saber, el operador "." y el operador "->". Entre ellos, el operador "." se usa para acceder directamente a los miembros de la variable de estructura, y el operador "->" se usa para acceder a los miembros señalados por el puntero a la variable de estructura.

Person John = {
    
    "John", 30, true};
Person *pJohn = &John;
cout << John.name << endl; // 使用 "." 运算符访问成员
cout << pJohn->age << endl; // 使用 "->" 运算符访问成员

En este ejemplo, definimos una variable de estructura denominada John y un puntero a la variable de estructura denominada pJohn. Luego, usamos los operadores "." y "->" para acceder a la variable de estructura y la variable miembro a la que apunta el puntero, respectivamente.

3.3 Inicialización de la estructura

Cuando declaramos una variable de estructura, si no hay una operación de inicialización explícita, las variables miembro de esta variable de estructura adoptarán el valor por defecto. Por ejemplo, en el ejemplo anterior, si no inicializamos la variable miembro de John, entonces el nombre de la variable miembro del tipo cadena se le asignará una cadena vacía, la variable miembro edad del tipo entero se le asignará 0 y el variable miembro de tipo booleano género se le asignará falso.

Por lo tanto, al escribir un programa, debemos inicializar las variables de estructura tanto como sea posible para garantizar que sus variables miembro tengan valores claros.

enumerar

1. El concepto de enumeración (Enum)

1.1 ¿Qué es una enumeración?

Una enumeración es un tipo de datos definido por el usuario que puede combinar múltiples constantes asociadas para formar un nuevo tipo de datos. Una enumeración consta de varios valores de enumeración (es decir, constantes o miembros de enumeración), cada miembro de enumeración tiene un nombre único y un valor entero correspondiente.

1.2 Definición de enumeración

En C++, podemos definir una enumeración de la siguiente manera:

enum Color {
    
    
    Red,
    Green,
    Blue
};

En este ejemplo, definimos un tipo de enumeración denominado Color. Este tipo de enumeración contiene tres miembros de enumeración: rojo, verde y azul. Entre ellos, cada miembro de la enumeración corresponde a un valor entero, que aumenta uno a uno desde 0 por defecto.

2. Uso de la enumeración

2.1 Inicialización de la enumeración

Las enumeraciones se pueden inicializar de las siguientes maneras:

Color c = Red;

En este ejemplo, definimos una variable llamada c y la inicializamos en el primer miembro de enumeración Red del tipo de enumeración Color. Esta variable representa un color.

2.2 Enumeraciones como parámetros de función

Las enumeraciones se pueden usar como parámetros para las funciones, lo que facilita el paso de múltiples constantes relacionadas a una función.

void printColor(Color c){
    
    
    switch(c){
    
    
        case Red:
            cout << "Red";
            break;
        case Green:
            cout << "Green";
            break;
        case Blue:
            cout << "Blue";
            break;
        default:
            cout << "Unknown color";
            break;
    }
}

En este ejemplo, definimos una función llamada printColor que toma un argumento de tipo Color. Esta función imprimirá el nombre del color.

2.3 Enumeraciones como constantes

Las enumeraciones se pueden usar como constantes en los programas para representar convenientemente valores específicos. Por ejemplo:

const int MAX_SIZE = 100;
enum {
    
    SUCCESS, FAILURE};

En este ejemplo, definimos una constante entera llamada MAX_SIZE y la inicializamos en 100. Al mismo tiempo, también definimos dos miembros de enumeración: ÉXITO y FALLO. Estas constantes se pueden usar para varios juicios lógicos en el programa.

3. Notas sobre la enumeración

3.1 Convenciones de nomenclatura para los miembros de la enumeración

Al definir los miembros de la enumeración, debemos seguir ciertas convenciones de nomenclatura para mejorar la legibilidad y la capacidad de mantenimiento del programa. Normalmente, usamos letras mayúsculas para indicar los miembros de la enumeración y guiones bajos para separar palabras, por ejemplo:

enum Gender {
    
    
    MALE,
    FEMALE
};

En este ejemplo, definimos un tipo de enumeración denominado Sexo, que incluye dos miembros de enumeración: MASCULINO y FEMENINO.

3.2 Problemas con el valor de los miembros de la enumeración

Al definir un miembro de enumeración, podemos asignarle explícitamente un valor entero. Por ejemplo:

enum Color {
    
    
    Red = 1,
    Green = 2,
    Blue = 4
};

En este ejemplo, definimos un tipo de enumeración denominado Color, que incluye tres miembros de enumeración: rojo, verde y azul. Entre ellos, el rojo corresponde al valor entero 1, el verde corresponde al valor entero 2 y el azul corresponde al valor entero 4.

Cabe señalar que, en un tipo de enumeración, el valor entero correspondiente a cada miembro de la enumeración debe ser único. Si asignamos diferentes valores enteros al mismo miembro de la enumeración varias veces, el compilador informará un error.

3.3 Problemas de tamaño de enumeración

Al usar enumeraciones, debemos prestar atención al espacio de memoria ocupado por el tipo de enumeración. Normalmente, el compilador convertirá automáticamente el valor entero correspondiente a un miembro de la enumeración en un valor de tipo int. Por lo tanto, al definir un tipo de enumeración, debemos asegurarnos de que los valores enteros correspondientes a todos sus miembros de enumeración puedan representarse mediante el tipo int, de lo contrario, puede causar un desbordamiento de datos u otros problemas.

4. Escenarios de aplicación enumerados

Las enumeraciones se utilizan a menudo para varios juicios lógicos y transiciones de estado en los programas. Por ejemplo, en el desarrollo de juegos, podemos usar enumeraciones para representar diferentes estados del juego, como:

enum GameState{
    
    
    Init,
    Playing,
    Paused,
    GameOver
};

Al mismo tiempo, en el diseño de interfaces gráficas, las enumeraciones se utilizan a menudo para representar diferentes tipos de control, como:

enum ControlType {
    
    
    Button,
    Textbox,
    Checkbox,
    Radiobutton
};

Estos tipos enumerados pueden hacer que el código del programa sea más claro y fácil de entender, y también facilitar la expansión y el mantenimiento del programa.