Estructura C++ con ejemplo

¿Qué es una Estructura en C++?

UNA ESTRUCTURA es una estructura de datos de C++ que se puede utilizar para almacenar juntos elementos de diferentes tipos de datos. En C++, una estructura es un tipo de datos definido por el usuario. La estructura crea un tipo de datos para agrupar elementos de diferentes tipos de datos en un solo tipo de datos.

Por ejemplo:

Suponga que necesita almacenar información sobre alguien, su nombre, ciudadanía y edad. Puede crear variables como nombre, ciudadanía y edad para almacenar los datos por separado.

Sin embargo, es posible que necesite almacenar información sobre muchas personas en el futuro. Significa que se crearán variables para diferentes individuos. Por ejemplo, nombre1, ciudadanía1, edad1, etc. Para evitar esto, es mejor crear una estructura.

En este tutorial de C++, aprenderá:

• ¿Qué es una estructura en C++?
• ¿Cuándo usar una estructura?
• Inicialización de la estructura C++
• Creación de instancias de Struct
• Acceder a los miembros de la estructura
• Puntero a la estructura
• Estructura como argumento de función
• Limitación de una estructura C++

¿Cuándo usar una Estructura?

Aquí hay algunas razones por las que se usa la estructura en C++.

• Utilice una estructura cuando necesite almacenar elementos de diferentes tipos de datos en un solo tipo de datos.
• Las estructuras de C++ son un tipo de valor en lugar de ser un tipo de referencia. Use una estructura si no tiene la intención de modificar sus datos después de la creación.

Inicialización de estructuras C++

Para crear una estructura C++, usamos la palabra clave struct, seguida de un identificador. El identificador se convierte en el nombre de la estructura. Esta es la sintaxis para la creación de una estructura C++:

Sintaxis:

struct struct_name  
{  
     // struct members
}   

En la sintaxis anterior, hemos utilizado la palabra clave struct. struct_name es el nombre de la estructura.

Los miembros de la estructura se agregan entre llaves. Estos miembros probablemente pertenecen a diferentes tipos de datos.

Por ejemplo:

struct Person  
{  
    char name[30];  
     int citizenship;  
     int age;  
}  

En el ejemplo anterior, Person es una estructura con tres miembros. Los miembros incluyen nombre, ciudadanía y edad. Un miembro es del tipo de datos char, mientras que los 2 restantes son enteros cuando se crea una estructura, no se asigna memoria. La memoria solo se asigna después de agregar una variable a la estructura.

Creación de instancias de estructura

En el ejemplo anterior, hemos creado una estructura llamada Persona. Podemos crear una variable de estructura de la siguiente manera:

Person p;

La p es una variable de estructura de tipo Persona. Podemos usar esta variable para acceder a los miembros de la estructura.

Acceso a miembros de la estructura

Para acceder a los miembros de la estructura, usamos la instancia de la estructura y el operador de punto (.). Por ejemplo, para acceder a la edad del miembro de la estructura Persona:

p.age = 27;

Hemos accedido a la edad del miembro de struct Person usando la instancia de struct, p. Entonces hemos establecido el valor de la edad del miembro en 27.

Ejemplo 1:

#include <iostream>    
using namespace std;
struct Person
{
	int citizenship;
	int age;
};
int main(void) {
	struct Person p;
	p.citizenship = 1;
	p.age = 27;
	cout << "Person citizenship: " << p.citizenship << endl;
	cout << "Person age: " << p.age << endl;

	return 0;
}

Salida:

Aquí hay una captura de pantalla del código:

Explicación del código:

1. Incluya el archivo de encabezado iostream en nuestro programa para usar las funciones definidas en él.
2. Incluya el espacio de nombres estándar para usar sus clases sin llamarlo.
3. Cree una estructura llamada Persona.
4. El comienzo del cuerpo de la estructura.
5. Cree un miembro de estructura llamado ciudadanía de tipo entero.
6. Cree un miembro de estructura llamado edad de tipo entero.
7. Fin del cuerpo de la estructura.
8. Llama a la función main(). La lógica del programa debe agregarse dentro del cuerpo de esta función.
9. Cree una instancia de la estructura Persona y asígnele el nombre p.
10. Establezca el valor de la ciudadanía de los miembros de la estructura en 1.
11. Establezca el valor de la edad del miembro de la estructura en 27.
12. Imprima el valor de la ciudadanía de los miembros de la estructura en la consola junto con otro texto.
13. Imprime el valor de la edad del miembro de la estructura en la consola junto con otro texto.
14. El programa debería devolver un valor si se ejecuta correctamente.
15. Fin de la función main().

Apuntadores a la estructura

Es posible crear un puntero que apunte a una estructura. Es similar a cómo se crean los punteros que apuntan a tipos de datos nativos como int, float, double, etc. Tenga en cuenta que un puntero en C++ almacenará una ubicación de memoria.

Ejemplo 2:

#include <iostream>
using namespace std;

struct Length
{
	int meters;
	float centimeters;
};

int main()
{
	Length *ptr, l;

	ptr = &l;

	cout << "Enter meters: ";
	cin >> (*ptr).meters;
	cout << "Enter centimeters: ";
	cin >> (*ptr).centimeters;
	cout << "Length = " << (*ptr).meters << " meters " << (*ptr).centimeters << " centimeters";

	return 0;
}

Salida:

Aquí hay una captura de pantalla del código:

Explicación del código:

1. Incluya el archivo de encabezado iostream en nuestro programa para poder usar sus funciones.
2. Incluya el espacio de nombres estándar en nuestro programa para usar sus clases sin llamarlo.
3. Cree una estructura llamada Longitud.
4. Inicio del cuerpo de la estructura Longitud.
5. Cree un miembro de estructura llamado metros de tipo de datos entero.
6. Cree un miembro de estructura llamado centímetros de tipo entero.
7. Fin del cuerpo de la estructura Longitud.
8. Llama a la función main().
9. Inicio del cuerpo de la función main().
10. Cree una variable de puntero *ptr y una variable normal l de tipo Longitud.
11. Almacene la dirección de la variable l en nuestra variable puntero.
12. Muestra un mensaje en la consola, solicitando al usuario que ingrese el valor de los medidores variables.
13. Lee el valor ingresado por el usuario a través del teclado. Aquí se accede a los medidores de función miembro usando la variable de puntero.
14. Muestra un mensaje en la consola, pidiéndole al usuario que ingrese el valor de los centímetros variables.
15. Lee el valor ingresado por el usuario a través del teclado. Aquí se accede a la función miembro centímetros usando la variable de puntero.
16. Muestre los valores leídos del usuario en la consola junto con otro texto.
17. El programa debe devolver un valor al ejecutarse con éxito.
18. Fin del cuerpo de la función main().

Estructura como argumento de función

Puede pasar una estructura a una función como argumento. Esto se hace de la misma manera que pasar un argumento normal. Las variables de estructura también se pueden pasar a una función. Un buen ejemplo es cuando necesita mostrar los valores de los miembros de la estructura. Demostremos esto:

Ejemplo 3:

#include<iostream>
using namespace std;

struct Person
{
	int citizenship;
	int age;
};

void func(struct Person p);

int main()
{
	struct Person p;

	p.citizenship = 1;
	p.age = 27;

	func(p);
	return 0;
}
void func(struct Person p)
{
	cout << " Person citizenship: " << p.citizenship<<endl;
	cout << " Person age: " << p.age;
}

Salida:

Aquí hay una captura de pantalla del código:

Explicación del código:

1. Incluya el archivo de encabezado iostream en nuestro archivo. Luego usaremos sus funciones sin obtener errores.
2. Incluya el espacio de nombres estándar en nuestro programa para usar sus clases. No necesitaremos llamar al espacio de nombres para usar sus clases.
3. Cree una estructura llamada Persona.
4. Inicio del cuerpo de la estructura Persona.
5. Cree un miembro de la estructura Persona. El miembro se denomina ciudadanía y es de tipo entero.
6. Cree un miembro de la estructura Persona. El miembro se llama edad y es de tipo entero.
7. Fin del cuerpo de la estructura Persona.
8. Cree una función que tome la instancia de la estructura Persona, p, como argumento.
9. Llama a la función principal. El { marca el comienzo del cuerpo de la función main().
10. Cree una instancia de estructura Persona y asígnele el nombre p.
11. Acceda a la variable miembro de la estructura ciudadanía usando la instancia de la estructura, p, y asignándole el valor 1.
12. Acceda a la edad de la variable miembro de la estructura utilizando la instancia de la estructura, p, y asignándole el valor 27.
13. Llamar a la función y pasarle la instancia de la estructura Persona, p, como argumento.
14. La función debe devolver un valor al ejecutarse con éxito.
15. Fin del cuerpo de la función main().
16. Cree el cuerpo de la función.
17. El comienzo del cuerpo de la función.
18. Acceda al valor de ciudadanía del miembro de la estructura e imprímalo en la consola junto con otro texto.
19. Acceda al valor de edad del miembro de la estructura e imprímalo en la consola junto con otro texto.
20. Fin del cuerpo de la función.

Limitación de una estructura C++

Las siguientes son las limitaciones de las estructuras:

• El tipo de datos de estructura no se puede tratar como tipos de datos integrados.
• Los operadores como + - y otros no se pueden usar en variables de estructura.
• Las estructuras no admiten la ocultación de datos. Cualquier función puede acceder a los miembros de una estructura, independientemente de su alcance.
• Los miembros estáticos no se pueden declarar dentro del cuerpo de la estructura.
• Los constructores no se pueden crear dentro de una estructura.

Resumen:

• Una estructura es una estructura de datos que almacena elementos de datos que pertenecen a diferentes tipos.
• Mientras que una matriz almacena elementos de datos de un tipo similar, una estructura almacena elementos de datos de diferentes tipos.
• Se debe usar una estructura cuando no se espera que los elementos de datos cambien de valor.
• Se accede a los miembros de una estructura mediante el operador de punto (.).
• Tenemos que crear una instancia de la estructura.
• Para crear una estructura C++, usamos la palabra clave struct.
• Los punteros que apuntan a una estructura se crean de manera similar a como se crean los punteros que apuntan a tipos regulares.
• Se puede pasar una estructura como argumento a una función de la misma manera que se pasan las funciones ordinarias.