STRUCT
Una
estructura es un tipo de dato compuesto que permite almacenar un conjunto
de datos de diferente tipo. Los datos que contiene
una estructura pueden ser de tipo simple (caracteres, números enteros o de coma
flotante etc.) o a su vez de tipo compuesto (vectores, estructuras, listas,
etc.).
struct ejemplo {
char c;
int i;};
En C/C++ se forma una estructura utilizando la
palabra reservada struct, seguida por un campo etiqueta opcional, y luego una
lista de miembros dentro de la estructura. La etiqueta opcional se utiliza para
crear otras variables del tipo particular de la estructura:
En esta sintaxis aclararemos que:
|
struct: es una palabra reservada de C que indica
que los elementos que vienen agrupados a continuación entre llaves componen
una estructura. |
|
|
|
nombre_estructura: identifica el tipo de dato que se
describe y del cual se podrán declarar variables. Se especifica entre corchetes para indicar su
opcionalidad. |
|
|
|
miembro1, miembro2,...: Son los elementos que componen la
estructura de datos, deben ser precedidos por el tipo_dato al
cual pertenecen. |
DECLARACIÓN DE VARIABLES
La declaración de variables de un determinado tipo de estructura de
datos se puede realizar de dos modos:
Primera: Incluir
en la propia definición de la estructura aquellas variables que se van a
emplear en el programa. Esta declaración de variables implica que el
ámbito en el que éstas son reconocidas será el mismo que el de la declaración
del tipo de dato estructura.
|
En
estos casos, y si no se van a declarar más variables de este tipo de dato en
otros lugares del programa, el nombre_estructura es
innecesario, por ello viene entre corchetes. |
Ejemplo: estructura
de una tarjeta bancaria, utilizando esta primera forma:
|
struct { |
|
long_int num_tarjeta; |
|
char
tipo_cuenta; |
|
char
nombre [80]; |
|
float saldo; |
|
} cliente1,
cliente2; |
Segunda: Definir el tipo de dato estructura con un nombre determinado y declarar posteriormente las variables de ese tipo de dato. Para ello la estructura se identificará con un nombre de forma obligatoria.
Ejemplo: estructura
de una tarjeta bancaria, utilizando la segunda forma:
|
struct { |
|
long_int num_tarjeta; |
|
char
tipo_cuenta; |
|
char
nombre [80]; |
|
float saldo; |
|
} |
|
struct tarjetas
cli1, cli2; |
VÍDEOS DE APOYO (STRUCT)
TYPEDEF
La palabra reservada typedef se
utiliza para asignar un alias (otro nombre) a un tipo. No crea ningún nuevo
tipo, solo define un nuevo identificador para un tipo que ya tiene su propio
identificador (el identificador puede ser un nombre o una expresión compleja
que contiene al nombre). Es importante recalcar que el nuevo nombre es un
añadido, y no sustituye al identificador original. Ambos
identificadores pueden ser intercambiados libremente en cualquier expresión.
Formalmente typedef es un
especificador de identificador (nombre). Su introducción en el lenguaje se debe
a que, como reconoce su propio creador [1], la sintaxis de declaraciones
C++ es innecesariamente dura de leer y escribir. Esto se debe a la herencia del
C y a que la notación no es lineal, sino que mimetiza la sintaxis de las
expresiones que está basada en precedencias. En este sentido, la utilización
de typedef permite
paliar en parte el problema, mejora la legibilidad y ayuda a la documentación y
mantenimiento del programa, ya que permite sustituir identificadores de tipo
complejos por expresiones más sencillas.
Sintaxis:
typedef <tipo>
<alias>;
Asigna un
nombre <alias> con el tipo de dato
de <tipo>.
Nota: para distinguir un
identificador <alias> introducido con un typedef de un
nombre de tipo normal <tipo>,
al primero se le denomina nombre-typedef ("typedef-name") o
alias-typedef ("typedef-alias").
Los typedef pueden ser
usados con tipos simples o abstractos, pero no con nombres de
funciones.
Ejemplo básico de typedef
Considere este código:
int main(void){ int notas; notas=100; return 0;}
Ahora considere esto :
int main(){ typedef int nota_alumno_t; nota_alumno_t notas; notas=100; return -1;}Ambas secciones de código hacen lo
mismo: crean un tipo int (notas) y le dan un valor de 100. El método para hacer esto en la segunda sección hace
que sea más legible porque la declaración typedef hace
que nota_alumno_t signifique lo mismo que int. En este ejemplo, la variable notas guarda las "notas" de un estudiante,
así que definir notas como una variable de tipo nota_alumno_t le da al nombre de esa variable un contexto.
DECLARACIÓN DE VARIABLES
El
lenguaje C ofrece la posibilidad de definir sus propios tipos a partir de los
tipos base. Para ello, hay que utilizar el comando typedef. El principio es
sencillo: declarar una variable del tipo deseado, añadir typedef delante... y
el nombre de la variable es un sinónimo del tipo de esta variable. Por ejemplo:
typedef int toto;
Permite
definir el tipo «toto» en un programa; toto se convierte en sinónimo de int y
puede usarse como tal en todo el programa:
typedef int toto;
int main()
{
toto prueba=80;
printf("la variable prueba vale: %d\n",prueba);
return 0;
}
Lo
interesante de poder rebautizar sus tipos depende de las situaciones. Por
ejemplo, para crear un lenguaje en español. Pero se utiliza casi
automáticamente con las tuplas para hacer desaparecer la palabra clave struct.
Sea
por ejemplo el tipo struct enemigo en un programa:
struct enemigo{
char tipo; // tipo del enemigo (una letra)
float molestia; // potencial de molestia
float x,y,px,py; // posición y desplazamiento
int fuerza; // indicador de la fuerza de combate
};
Añadiendo
la palabra clave typedef delante, se puede definir un sinónimo de struct
enemigo de la forma siguiente:
typedef struct enemigo{
char tipo;
float molestia;
float x,y,px,py;
int fuerza;
}t_enemigo;
y
de forma más concisa se puede definir su tipo de tupla:
typedef struct{
char tipo;
float molestia; ...
Una declaración typedef se interpreta de la misma manera que una declaración de variable o función, pero el identificador, en lugar de asumir el tipo especificado por la declaración, se convierte en un sinónimo del tipo.
¿Cómo elegir los
nombres de los tipos y los nombres de las variables? No existen reglas precisas
al respecto, pero te recomendamos para los nombres de tipos usar siempre un
prefijo que comience con mayúsculas que podría ser Tipo y para las variables un
nombre que comience por minúsculas. Es un convenio que siguen muchos
programadores, aunque no es obligatorio. Los nombres de tipos y variables deben
ser lo más descriptivos posibles para hacer el programa fácil de leer y de
entender. Piensa que es válido tanto declarar typedef int TipoVectorInt; como
typedef int TVI; Sin embargo es más correcto usar TipoVectorInt que TVI porque
resulta más descriptivo de la función y cometido del tipo VectorInt que tres
letras cuyo significado es poco entendible.
VÍDEOS DE APOYO (TYPEDEF)
No hay comentarios.:
Publicar un comentario