Aprendiendo C/C++ Paso a Paso - Página 10

10. Paso a Paso C/C++ — Programación en C - Estructura

Estructuras

| | 1. Introducción

2. Declaración de Estructura
3. Definición de una Variable de Estructura
4. Inicialización de una Variable de Estructura
5. Asignación directa de estructuras
6. Cálculo del tamaño de la Estructura
7. Estructuras Anidadas
8. Arreglo de Estructuras
9. Arreglos dentro de Estructuras
10. Pasando Estructuras a Funciones
11. Retornando Estructuras de Funciones
12. Puntero a estructura
13. Estructura que contiene Punteros
14. Estructuras Auto-referenciales |

1. Introducción

| | int a[4] = { 3, 4, 5, 6 };                / Expresión válida /
int a[4] = { 3, 4.23, 5, 6 };                / Expresión inválida /
int a[4] = { 3, “Siglov”, 5,3}                / Expresión inválida / |

¿Por qué las dos últimas expresiones son inválidas? Un arreglo puede almacenar valores del mismo tipo. Deben ser del mismo tipo. Mientras que una estructura puede contener más de un tipo de dato según su definición.

| | • Un grupo de una o más variables de diferentes tipos de datos organizadas juntas bajo un solo nombre se llama estructura o
• Una colección de tipos de datos heterogéneos (dísimiles) agrupados bajo un solo nombre se llama estructura o
• Una estructura es una colección de variables simples. Las variables en una estructura pueden ser de diferentes tipos. Los elementos de datos en una estructura se llaman miembros de las estructuras. |

2. Declaración de una estructura

Cuando se define una estructura, todo el grupo se referencia a través del nombre de la estructura. Los componentes individuales presentes en la estructura se llaman miembros de la estructura y estos pueden ser accedidos y procesados por separado.

| | |

Ej:

| | struct date
{
int day;
int month;
int year;
}; | struct student
{
int sno;
char name[20];
int marks;
float avg;
}; |

3. Definición de una Variable de Estructura

Definir una variable de estructura es lo mismo que definir un tipo de dato incorporado como int.

| | int a;                             /  válido /
date d;                          / válido (Pero solo en C++) /
struct date d;                 / válido en C y C++  / |

4. Inicializando una Variable de Estructura

Los miembros de la estructura pueden ser inicializados como otras variables. Esto se puede hacer en el momento de la declaración o en el tiempo de diseño.

| 1. Inicialización en la Declaración:
struct ddate
{
int day;
int month;
int year;
} d = { 27, 10, 2000 }; | 2. Inicialización en la Definición:
struct ddate d = { 27, 10, 2000 }; | | 1. Inicialización en tiempo de diseño: ddate d;
d.day = 27;
d.month = 10;
d.year = 2000; | 4. Inicialización en tiempo de ejecución:
scanf(“%d%d%d”, &d.day, &d.month, &d.year); |

Ej:

| | / Escribir un programa para aceptar e imprimir los detalles de un empleado /
/ 73_struct.c /
#include
struct emp
{
int eno;
char name[20];
float sal;
};
int main()
{
struct emp e;

printf(“Ingrese el número de empleado    :”); scanf(“%d”, &e.eno);
printf(“Ingrese el nombre del empleado       :”); scanf(“%s”, e.name);
printf(“Ingrese el salario del empleado      :”); scanf(“%d”, &e.sal);
printf(“\n\nLos detalles del empleado son los siguientes…. “);
printf(“%d    %s      %d”, e.eno, e.name, e.sal);
return 0;
} |

5. Asignación directa de estructuras

La asignación directa de más de una variable es posible utilizando estructuras.

| | struct emp a, b = {1001, “Vimal”, 6700.00 };
a = b; / Válido /
printf(“%d %s %d” , a.eno, a.name, a.sal ); | | | Salida:
1001 Vimal 6700.00 |

6. Cálculo del tamaño de la estructura

Cada tipo de dato en C/C++ tiene un tamaño especificado, es decir, int tiene 2 bytes de tamaño, float tiene 4 bytes de tamaño y así sucesivamente. Aquí está la forma de encontrar el tamaño de una variable de estructura.

sizeof:- Esta función se utiliza para encontrar el tamaño de una variable dada.

| | printf(“%d”, sizeof(int));                           / 2  /
printf(“%d”, sizeof(float));                       / 4  /
printf(“%d”, sizeof(struct emp));              / Muestra el tamaño de la estructura emp / |

7. Estructuras Anidadas

Estructura dentro de estructuras se conoce como estructuras anidadas. Para acceder a los miembros de la estructura anidada debemos aplicar el operador punto dos veces al llamar a los miembros de la estructura.

Ej:

| | / programa para demostrar la estructura anidada con la estructura de empleado /
/ 74_nested.c /
#include
struct emp
{
int eno;
char name[10];
float sal;
struct                                                    / Estructura Anidada  /
{
street char[10];
city char[10];
} addr;
};
int main()
{
struct emp e;
printf(“Ingrese emp_no, emp_name, emp_sal, street, city “);
scanf(“%d%s%d%s%s”, &e.eno, e.name, &e.sal, e.addr.street, e.addr.city );
printf(“\n\nLos detalles del empleado son los siguientes   …. “);
printf(“%d%s%d%s%s”, e.eno, e.name, e.sal, e.addr.street, e.addr.city );
return 0;
} |

8. Arreglo de Estructuras

Podemos crear un arreglo de estructuras. El arreglo tendrá estructuras individuales como sus elementos.

| | / Escribir un programa para aceptar e imprimir los detalles de un empleado /
/ 75_array.c  /
#include
struct emp
{
int eno;
char name[20];
float sal;
};
int main()
{
struct emp e [10];
int i;
for(i = 0; i<10; i++)
{
printf(“Ingrese el número de empleado    :”); scanf(“%d”, &e [i].eno);
printf(“Ingrese el nombre del empleado       :”); scanf(“%s”, e [i].name);
printf(“Ingrese el salario del empleado     :”); scanf(“%d”, &e [i].sal);
}
printf(“\n\nLos detalles del empleado son los siguientes…. “);
for(i = 0; i<10; i++)
printf(“%d    %s      %d”, e [i].eno, e [i].name, e [i].sal);
return 0;
} |

Nada es nuevo en el programa anterior. Todo el programa es el mismo que el programa estructurado simple excepto los datos marcados.

9. Arreglos dentro de Estructuras

Puede haber una situación para utilizar arreglos dentro de estructuras. Cómo lograr arreglos dentro de estructuras. Aquí está el enfoque con un programa simple.

| | / Programa para aceptar e imprimir la información de un estudiante  /
/ 76_array.c /
#include
struct stud
{
int sno;
char name[10];
int marks[5];                              / Arreglo dentro de la estructura /
};
int main()
{
struct stud s;
int i;
printf(“Ingrese el número de estudiante  “); scanf(“%d”, &s.sno);
printf(“Ingrese el nombre del estudiante          “); scanf(“%d”, s.name);
for( i = 0; i<3; i++)
{
printf(“Ingrese las calificaciones del estudiante  “); scanf(“%d”, &s.marks[i]);
}
printf(“\n\nLos registros del estudiante son los siguientes…. “);
printf(“%d  %s  %d  %d  %d”, s.sno, s.name, s.marks[0], s.marks[1], s.marks[2] );
return 0;
} |

10. Pasando Estructuras a Funciones

Es posible enviar estructuras completas a funciones como argumentos en la llamada a la función. La variable de estructura se trata como cualquier variable ordinaria.

| | / Programa para pasar una variable de estructura a una función /
/ 77_funct.c /
#include
struct emp
{
int eno;
char name[10];
float sal;
};
void display(struct emp temp);
int main()
{
struct emp e;
display(e);
return 0;
}
void display(struct emp temp)
{
printf(“%d  %s  %d”, temp.eno, temp.name, temp.sal );
} |

11. Retornando Estructuras de funciones

Podemos retornar estructuras de funciones. Sí, las estructuras pueden ser retornadas de funciones al igual que las variables de cualquier otro tipo.

| | / Retornando objeto de estructura de una función /
/ 78_funct.c /
struct emprec
{
int eno;
char name[10];
};
struct emprec read();
void write(struct emprec t);
int main()
{
struct emprec e;
e = read();
write(e);
return 0;
}
void write(struct emprec t)
{
printf(“\n\n%d  %s”, t.eno, t.name);
}
struct emprec read()
{
struct emprec t;
printf(“Ingrese el número de empleado   :”); scanf(“%d”, &t.eno);
printf(“Ingrese el nombre del empleado         :”); scanf(“%s”, t.name);
return t;
} |

12. Puntero a Estructura

Hasta ahora hemos visto que los miembros de una estructura pueden ser de tipos de datos como int, char, float o incluso estructura. El lenguaje C/C++ también permite declarar una variable puntero como miembro de una estructura. Las variables puntero pueden ser utilizadas para almacenar la dirección de una variable de estructura también. Un puntero puede ser declarado como si apunta a un tipo de dato de estructura.

| | / Programa para demostrar el proceso de Puntero a estructura /
/ 79_pointer.c /
#include
struct employee
{
int eno;
char name[10];
};
struct employee emp;
int main()
{
emp = (struct employee )malloc(sizeof(emp));
printf(“Ingrese los detalles del empleado ..”);
scanf(“%d%s%”, &emp->eno, emp->name);
printf(“\n\n%d   %s”, emp->eno, emp->name);
return 0;
} |

Los datos marcados son esenciales para implementar puntero a estructura.
La siguiente declaración es opcional, pero es mejor utilizarla para organizar una mejor gestión de memoria.
emp = (struct employee * )malloc(sizeof(emp));

13. Estructuras que Contienen Punteros

Una variable puntero también puede ser utilizada como miembro en la estructura.
El siguiente programa contiene miembros puntero contenidos por una variable puntero de estructura.

| | / programa para demostrar el uso de estructuras que contienen Punteros /
/ 80_pointers.c  /
#include
struct
{
int a;
int b;
} *temp;
int main()
{
int x, y;
x = 20; y = 50;
rk -> a = &x;
rk -> b = &y;

printf(“%d %d “, temp->a, temp->b );
return 0;
} | | | salida:
20    50 |

14. Estructuras Auto-referenciales

Las estructuras pueden tener miembros, que son del tipo de la misma estructura en la que están incluidas. Esto es posible con punteros y el fenómeno se llama estructuras auto-referenciales.

| | struct emp
{
int eno;
char name[10];
struct emp *e;
}; |

Las estructuras auto-referenciales pueden ser utilizadas principalmente en la organización de datos, ordenación, búsqueda de elementos, inserción, eliminación de elementos y así sucesivamente.

Este enfoque conduce a Estructuras de Datos (es decir, Listas Enlazadas, Pilas, Colas, Árboles y Grafos).