Estructuras de Datos en C/C++: Definición, Declaración y Uso
Enviado por Programa Chuletas y clasificado en Informática y Telecomunicaciones
Escrito el en español con un tamaño de 8,28 KB
Estructuras (struct
)
Las estructuras (struct
) son colecciones de variables relacionadas que se referencian bajo un mismo nombre. Permiten agrupar datos de diferentes tipos en una sola entidad.
Definición de una Estructura
El siguiente fragmento define una estructura con los campos nombre, calle, ciudad, edo y codigo:
struct dire {
char nombre[30];
char calle[40];
char ciudad[20];
char edo[3];
unsigned long int codigo;
};
struct
(palabra reservada para definir una estructura) indica al compilador que se va a definir una estructura.dire
(rótulo de la estructura) da nombre a la definición de la estructura.- Las variables declaradas dentro de las llaves de la definición de la estructura son los miembros de la estructura. Los miembros de la estructura deben tener nombres únicos, pero dos estructuras diferentes pueden contener miembros con el mismo nombre sin conflicto.
- Cada definición de estructura debe terminar con punto y coma (
;
).
El formato general de una definición de estructura es:
struct nombre_tipo_de_estructura {
tipo nombre_elemento1;
tipo nombre_elemento2; // Miembros
// ...
tipo nombre_elemento_n;
} variables_estructura;
struct
define un determinado tipo de estructura (nombre_tipo_de_estructura
) y declara lasvariables_estructura
del mismo tipo.- Si solo se necesita una variable estructurada, no es necesario incluir el nombre de la estructura.
NOTA: Se puede omitir el nombre de la estructura o las variables estructura, pero no ambos. Si la definición de una estructura no contiene un nombre de rótulo de estructura, las variables de ese tipo de estructura solo pueden ser declaradas dentro de la definición de estructura, y no en una declaración por separado.
Ejemplos de definición de estructuras:
struct tarjeta {
char nombre[60];
int edad;
} a, varios[10];
struct datos_empleado {
char nombre[60];
char direccion[40];
char rfc[10];
int edad;
char sexo;
float salario;
};
struct cliente {
char nombre[60];
char referencia[10];
int pedido;
} tipoa, tipob;
struct producto {
char descripcion[100];
char clave[5];
int cantidad;
float precio;
};
struct dire {
char codigo[6];
char call[20];
int num;
} direccion;
Declaración de Variables de Tipo Estructura
A continuación de la definición de la estructura (en caso de que no se indiquen las variables_tipo_estructura
) se realiza la declaración de variables de tipo estructura.
struct producto articulo; // tipo de dato definido por el usuario. Nombre de la variable de tipo estructura.
Operaciones Válidas con Estructuras
Las únicas operaciones válidas que pueden ejecutarse sobre estructuras son:
- Asignar variables de estructura a variables de estructura del mismo tipo.
- Tomar la dirección (&) de una variable de estructura.
- Obtener acceso a los miembros de una variable de estructura.
- Utilizar el operador
sizeof
para determinar el tamaño de la variable de estructura.
Las estructuras no pueden compararse entre sí directamente, porque los miembros de las estructuras no están necesariamente almacenados en bytes de memoria consecutivos.
En un programa, normalmente, la definición de estructuras antecede a la función main()
, por lo que puede ser utilizada para declarar variables en todas las funciones del programa.
Operador sizeof
El operador unario especial sizeof
determina el tamaño de un arreglo en bytes (o de cualquier otro tipo de datos) durante la compilación de un programa. Cuando se aplica al nombre de un arreglo, el operador sizeof
regresa como un entero el número total de bytes del arreglo.
Sintaxis:
sizeof(nombre_arreglo)
El operador sizeof
puede ser aplicado a cualquier nombre de variable, tipo o constante. Al ser aplicado a un nombre de variable (que no sea un nombre de arreglo), o a una constante, será regresado el número de bytes utilizados para almacenar el tipo específico de variable o de constante.
Inicialización de Estructuras
Las estructuras pueden ser inicializadas mediante listas de inicialización como con los arreglos.
Para inicializar una estructura, se escribe en la declaración de la estructura, a continuación del nombre de la variable, un signo igual, con inicializadores encerrados entre llaves y separados por comas. Por ejemplo:
struct producto articulo = {"lápiz", "005B", 5, 1.50};
// Crea la variable a de tipo struct producto e inicializa el miembro descripción a "Lápiz", clave a "005B", cantidad a 5 y precio a 1.50.
Si en la lista aparecen menos inicializadores que en la estructura, los miembros restantes automáticamente quedarán inicializados a 0 (o NULL
si el miembro es un apuntador). Las variables de estructura declaradas por fuera de una definición de función (es decir, en forma externa) se inicializan a 0 o NULL
si en la declaración externa no se inicializan de forma explícita. Las variables de estructura también pueden ser inicializadas en enunciados de asignación, asignándoles una variable de estructura del mismo tipo, o asignando valores a los miembros individuales de la misma.
Acceso a los Miembros de una Estructura
Para tener acceso a miembros de estructuras se utilizan dos operadores:
- El operador de miembro de estructura (
.
), también llamado operador punto. - El operador de apuntador de estructura (
->
), también llamado operador de flecha (Tema de apuntadores).
Para tener acceso al miembro de una estructura, se especifica el nombre de la variable de estructura, seguido por un punto y el nombre del miembro.
Por ejemplo, para imprimir el miembro clave de la estructura articulo correspondiente a la descripción de producto:
cout estructura. operador de miembro de estructura
El formato general es:
-------------------------------------------------------
nombre_estructura.nombre_elemento
-------------------------------------------------------
Mediante el uso del operador de miembro de estructura, también podemos asignar los valores a los miembros de la estructura.
articulo.descripción = “Escritorio tipo universal ...”;
articulo.precio = 738.10;
Un elemento de una estructura puede ser simple o compuesto. Un elemento simple es un int, float, unsigned int, char, etc. Los elementos complejos de tipo arreglo también se pueden referenciar en una estructura.
Por ejemplo,
struct empleado {
int a[10] [10];
float b;
} y;
Para referenciar al valor 3, 7 en el arreglo a de la estructura, se escribiría:
y.a[3][7]
Cuando una estructura es un elemento de otra estructura, se llama estructura anidada. Por ejemplo, el elemento dirección de la variable estructura se anida en empleado en este
Ejemplo:
struct empleado {
struct dire dirección;
float salario;
} trabajador;
Para referenciar los elementos de la estructura anidada nos valemos del operador punto, referenciando de izquierda a derecha, de la parte externa a la más interna:
trabajador.dirección.codigo = 98765;