Estructuras

Enviado por Programa Chuletas y clasificado en Informática y Telecomunicaciones

Escrito el en español con un tamaño de 8,9 KB

 
Estructuras (struct):son colecciones de variables relacionadas que se referencian bajo un mismo nombre.
El siguiente fragmento define una estructura con los campos
nombre y dirección.
 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) dice 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 entrar en conflicto.
Cada definición de estructura debe terminar con punto y coma ( ; ).
Por lo tanto, 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 las variables_estructura del mismo tipo.
Si sólo se necesita una
variable estructurada, no se necesita incluir el nombre de la estructura.
NOTA: Se puede omitir el nombre de la estructura o las variables estructura, pero no ambas. Si la definición de una estructura no contiene un nombre de rótulo de estructura, las variables de ese tipo de estructura pueden únicamente ser declaradas dentro de la definición de estructura, y no en una declaración por separado.

Por ejemplo, definimos las siguientes 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;

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
.

Las únicas
operaciones válidas que pueden ejecutarse sobre estructuras son: asignar variables de estructura a variables de estructura del mismo tipo, tomando la dirección (&) de una variable de estructura, obteniendo acceso a los miembros de una variable de estructura, y utilizando el operador sizeof, a fin de determinar el tamaño de la variable de estructura.
Las estructuras no pueden compararse entre sí, 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 al 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 del bytes del arreglo. Para esto, se utiliza de la siguiente manera:
sizeof (nombre_arreglo)
El operador
sizeof puede ser aplicado a cualquier nombre de variable, tipo o constante. Al se aplicado aun 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.

Inicializando estructuras
Las estructuras pueden ser inicializadas mediante listas de inicialización como con los arreglos.
Para inicializar una estructura, escriba 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, la declaración:
struct producto articulo = {“lápiz”, “005B”, 5, 1.50};
//crea la variable
a de tipo struct producto (como fue definido anteriormente) 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.

Cómo tener 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, y 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;

Entradas relacionadas: