Estructuras de Datos en C++: Construyendo Programas Eficientes con Arrays, Structs y Más

Los arrays de C/C++ te permiten definir variables que combinan varios elementos de datos del mismo tipo, pero la estructura (struct) es otro tipo de dato definido por el usuario que te permite combinar elementos de datos de diferentes tipos.

Las estructuras se usan para representar un registro; supongamos que quieres hacer un seguimiento de tus libros en una biblioteca. Podrías querer rastrear los siguientes atributos sobre cada libro:

• Título
• Autor
• Asunto
• ID del Libro

Definiendo una Estructura

Para definir una estructura, debes usar la declaración struct. La declaración struct define un nuevo tipo de dato, con más de un miembro, para tu programa. El formato de la declaración struct es este:

struct [etiqueta_estructura] {
    definición_miembro;
    definición_miembro;
    ...
    definición_miembro;
} [una_o_más_variables_estructura];

La etiqueta de estructura es opcional y cada definición de miembro es una definición de variable normal, como int i; o float f; o cualquier otra definición de variable válida. Al final de la definición de la estructura, antes del punto y coma final, puedes especificar una o más variables de estructura pero es opcional. Aquí está la forma en que declararías la estructura Libro:

struct Libros {
    char titulo[50];
    char autor[50];
    char asunto[100];
    int id_libro;
} libro;

Accediendo a Miembros de Estructura

Para acceder a cualquier miembro de una estructura, usamos el operador de acceso a miembro (.). El operador de acceso a miembro se codifica como un punto entre el nombre de la variable de estructura y el miembro de estructura al que deseamos acceder. Usarías la palabra clave struct para definir variables de tipo estructura. El siguiente es un ejemplo para explicar el uso de estructura:

#include <iostream>
#include <cstring>
using namespace std;
struct Libros {
    char titulo[50];
    char autor[50];
    char asunto[100];
    int id_libro;
};
int main() {
    struct Libros Libro1; // Declarar Libro1 de tipo Libro
    struct Libros Libro2; // Declarar Libro2 de tipo Libro
    // especificación libro 1
    strcpy(Libro1.titulo, "Aprende Programación C++");
    strcpy(Libro1.autor, "Chand Miyan");
    strcpy(Libro1.asunto, "Programación C++");
    Libro1.id_libro = 6495407;
    // especificación libro 2
    strcpy(Libro2.titulo, "Facturación Telecom");
    strcpy(Libro2.autor, "Yakit Singha");
    strcpy(Libro2.asunto, "Telecom");
    Libro2.id_libro = 6495700;
    // Imprimir info Libro1
    cout << "Libro 1 título: " << Libro1.titulo << endl;
    cout << "Libro 1 autor: " << Libro1.autor << endl;
    cout << "Libro 1 asunto: " << Libro1.asunto << endl;
    cout << "Libro 1 id: " << Libro1.id_libro << endl;
    // Imprimir info Libro2
    cout << "Libro 2 título: " << Libro2.titulo << endl;
    cout << "Libro 2 autor: " << Libro2.autor << endl;
    cout << "Libro 2 asunto: " << Libro2.asunto << endl;
    cout << "Libro 2 id: " << Libro2.id_libro << endl;
    return 0;
}

Cuando el código anterior se compila y ejecuta, produce el siguiente resultado:

Libro 1 título: Aprende Programación C++
Libro 1 autor: Chand Miyan
Libro 1 asunto: Programación C++
Libro 1 id: 6495407
Libro 2 título: Facturación Telecom
Libro 2 autor: Yakit Singha
Libro 2 asunto: Telecom
Libro 2 id: 6495700

Estructuras como Argumentos de Función

Puedes pasar una estructura como argumento de función de manera muy similar a como pasas cualquier otra variable o puntero. Accederías a las variables de estructura de manera similar a como lo hiciste en el ejemplo anterior:

#include <iostream>
#include <cstring>
using namespace std;
void imprimirLibro(struct Libros libro);
struct Libros {
    char titulo[50];
    char autor[50];
    char asunto[100];
    int id_libro;
};
int main() {
    struct Libros Libro1; // Declarar Libro1 de tipo Libro
    struct Libros Libro2; // Declarar Libro2 de tipo Libro
    // especificación libro 1
    strcpy(Libro1.titulo, "Aprende Programación C++");
    strcpy(Libro1.autor, "Chand Miyan");
    strcpy(Libro1.asunto, "Programación C++");
    Libro1.id_libro = 6495407;
    // especificación libro 2
    strcpy(Libro2.titulo, "Facturación Telecom");
    strcpy(Libro2.autor, "Yakit Singha");
    strcpy(Libro2.asunto, "Telecom");
    Libro2.id_libro = 6495700;
    // Imprimir info Libro1
    imprimirLibro(Libro1);
    // Imprimir info Libro2
    imprimirLibro(Libro2);
    return 0;
}
void imprimirLibro(struct Libros libro) {
    cout << "Libro título: " << libro.titulo << endl;
    cout << "Libro autor: " << libro.autor << endl;
    cout << "Libro asunto: " << libro.asunto << endl;
    cout << "Libro id: " << libro.id_libro << endl;
}

Cuando el código anterior se compila y ejecuta, produce el siguiente resultado:

Libro título: Aprende Programación C++
Libro autor: Chand Miyan
Libro asunto: Programación C++
Libro id: 6495407
Libro título: Facturación Telecom
Libro autor: Yakit Singha
Libro asunto: Telecom
Libro id: 6495700

Punteros a Estructuras

Puedes definir punteros a estructuras de manera muy similar a como defines un puntero a cualquier otra variable de la siguiente manera:

struct Libros *puntero_estructura;

Ahora, puedes almacenar la dirección de una variable de estructura en el puntero definido arriba. Para encontrar la dirección de una variable de estructura, coloca el operador & antes del nombre de la estructura de la siguiente manera:

puntero_estructura = &Libro1;

Para acceder a los miembros de una estructura usando un puntero a esa estructura, debes usar el operador -> de la siguiente manera:

puntero_estructura->titulo;

Reescribamos el ejemplo anterior usando puntero a estructura, esperamos que esto sea fácil para entender el concepto:

#include <iostream>
#include <cstring>
using namespace std;
void imprimirLibro(struct Libros *libro);
struct Libros {
    char titulo[50];
    char autor[50];
    char asunto[100];
    int id_libro;
};
int main() {
    struct Libros Libro1; // Declarar Libro1 de tipo Libro
    struct Libros Libro2; // Declarar Libro2 de tipo Libro
    // Especificación Libro 1
    strcpy(Libro1.titulo, "Aprende Programación C++");
    strcpy(Libro1.autor, "Chand Miyan");
    strcpy(Libro1.asunto, "Programación C++");
    Libro1.id_libro = 6495407;
    // Especificación Libro 2
    strcpy(Libro2.titulo, "Facturación Telecom");
    strcpy(Libro2.autor, "Yakit Singha");
    strcpy(Libro2.asunto, "Telecom");
    Libro2.id_libro = 6495700;
    // Imprimir info Libro1, pasando dirección de estructura
    imprimirLibro(&Libro1);
    // Imprimir info Libro2, pasando dirección de estructura
    imprimirLibro(&Libro2);
    return 0;
}
// Esta función acepta puntero a estructura como parámetro.
void imprimirLibro(struct Libros *libro) {
    cout << "Libro título: " << libro->titulo << endl;
    cout << "Libro autor: " << libro->autor << endl;
    cout << "Libro asunto: " << libro->asunto << endl;
    cout << "Libro id: " << libro->id_libro << endl;
}

Cuando el código anterior se compila y ejecuta, produce el siguiente resultado:

Libro título: Aprende Programación C++
Libro autor: Chand Miyan
Libro asunto: Programación C++
Libro id: 6495407
Libro título: Facturación Telecom
Libro autor: Yakit Singha
Libro asunto: Telecom
Libro id: 6495700

La Palabra Clave typedef

Hay una forma más fácil de definir structs o podrías "crear alias" de los tipos que creas. Por ejemplo:

typedef struct {
    char titulo[50];
    char autor[50];
    char asunto[100];
    int id_libro;
} Libros;

Ahora, puedes usar Libros directamente para definir variables de tipo Libros sin usar la palabra clave struct. El siguiente es el ejemplo:

Libros Libro1, Libro2;

Puedes usar la palabra clave typedef para no-estructuras también de la siguiente manera:

typedef long int *pint32;
pint32 x, y, z;

x, y y z son todos punteros a long ints.