Estructuras tipo Struct
Descrição do Produto
Estructuras tipo Struct
En la creacion de soluciones para algunos problemas surge la necesidad de agrupar datos de diferente tipo o de manejar datos que serian muy dificil de describir en los tipos de datos primitivos, esta es la situacion en la que debemos aprovecharnos de las caracteristicas que hacen al lenguaje C especial, o sea el uso de estructuras, uniones y punteros.
Una estructura contiene varios datos. La forma de definir una estructura es haciendo uso de la palabra clave struct. Aqui hay ejemplo de la declaracion de una estructura:
Struct miestructura { Int i; Double j; Char s[25]; } variable;
"variable" es una instancia de “miestructura” y no es necesario ponerla aquí. Se podria omitir de la declaracion de “miestructura" y más tarde declararla usando:
Struct miestructura variable;
También es una práctica muy común asignarle un alias o sinónimo al nombre de la estructura, para evitar el tener que poner "struct mystruct" cada vez. C nos permite la posibilidad de hacer esto usando la palabra clave typedef, lo que crea un alias a un tipo:
Typedef struct miestructura miest;
Un struct es un tipo de datos complejo conformado
por un conjunto de campos de otros tipos (básicos o
complejos) asociados a un identificador:
struct [etiqueta]
{
tipo campo;
tipo campo;
...
};
struct persona
{
char nombre[20];
int edad;
float peso;
} yo,tu,ellos[10];
struct persona el={“Antonio López”,31,80};
struct persona *ella, todos[20];
El acceso a los campos de una estructura se hace por
medio de un punto (.) o de una flecha (->) si es un
puntero a estructura.
struct persona el, *ella, todos[20];
printf(“Su nombre %s\n”,el.nombre);
todos[2].edad=20;
ella=&todos[2];
printf(“La edad de ella es %d\n”,ella->edad);
Estructuras y funciones
Las estructuras de datos son tipos complejos y (aunque
ciertos compiladores lo admiten) no deben ser pasados
como argumentos ni devueltos por funciones. En su
lugar se usan punteros a dichas estructuras:
void evaluar_empleado(struct empleado* emp);
struct empleado* nuevo_empleado();
Definición de nuevos tipos Las sentencias typedef se usan para definir nuevos tipos en base a tipos ya definidos: typedef int boolean; typedef struct persona persona_t; typedef struct punto { int coord[3]; enum color col; } punto_t; persona_t p[4];
Definición de nuevos tipos Las sentencias typedef se usan para definir nuevos tipos en base a tipos ya definidos: typedef int boolean; typedef struct persona persona_t; typedef struct punto { int coord[3]; enum color col; } punto_t; persona_t p[4];
Que es una estructura
A diferencia de los arreglos donde los elementos son todos del mismo tipo, en una estructura s epuede considerar con un arreglo en el cual sus elementos individuales pueden ser de distintos tipos
Estos elementos individuales se llaman mie¿mbros conmonentes de la estructura
En c son mecanismos de forma mas versátil detraajar con fichas de ingfoi
Struct nopmbre_estruct{
Tipo1 miembro1;
Tipo2 miembro 2,
.
};
• La palabra struct define la estructura
• nombre_estructura es el nombre que identifica
estructuras de este tipo, (misma composición)
• miembro1, ..., miembroN, son declaraciones de
miembros individuales. Los miembros pueden ser
variables ordinarias, punteros, arreglos u otras estructuras.
Declaración
• Una vez que la composición a sido definida, las
variables de este tipo de estructuras pueden
declararse como sigue:
Sintaxis: struct nombre_estructura var1, var2, ..., varN;
• Es posible combinar la declaración de la estructura
con la declaración de las variables.
• En este caso, el nombre de la estructura es
opcional).
Declaración
• Sintaxis (2 posibilidades)
struct nombre_estructura{
tipo1 miembro1; tipo2 miembro2;
...................
tipoN miembroN;
} var1, var2,..., varN;
•ó
struct {
tipo1 miembro1; tipo2 miembro2;
................
tipoN miembroN;
} var1, var2,..., varN;
Ejemplo
struct cuenta {
int numero_cuenta;
char tipo_cuenta; char nombre[30];
float saldo;
};
struct cuenta cliente1, cliente2;
struct cuenta {
int numero_cuenta;
char tipo_cuenta; char nombre[30];
float saldo;
} cliente1, cliente2;
Definición de estructura. 1. Esta estructura se llama cuenta y contiene cuatro miembros;
2. Declaración de 2 variables de tipo cuenta. 3. Combinación de la declaración de la estructura con la de las variables.
• Una estructura puede ser miembro de otra, (el ANSI
establece que se puede anidar hasta 15 estructuras, pero la mayoría de los compiladores admiten más ).
• En tal situación, la declaración de la estructura Anidamiento de estructuras.
Declaración de una
estructura fecha.
interna debe aparecer antes que la declaración de la estructura externa.
• También se pueden definir arreglos de estructuras.
struct cuenta {
int numero_cuenta;
char tipo_cuenta; char nombre[30];
struct fecha ultimo_pago;
} clientes[100];
2. Declaración una
estructura con el
nombre cuenta donde el último miembro es
una estructura
previamente declarada.
3. Declaración de un arreglo
de 100 estructuras de tipo cuenta.
Inicialización de una Estructura
• Una estructura puede inicializarse en el momento de
su declaración.
• La estructura debe tener un almacenamiento estático
para poderse inicializar en el momento de su declaración. Esto significa que debe ser una estructura global o (static).
Ejemplo
Inicialización de una estructura
struct fecha {
char nombre[80];
int mes;
int dia;
int anio;
};
1. Inicialización de los campos de la estructura nacimiento.
static struct fecha nacimiento = {"Ana" , 5, 24, 90};
Ejemplo
2. Inicialización de un arreglo
static struct fecha nacimientos[]={"Ana" , 5, 24, 66,
"Jose", 12, 30, 73,
"Raúl", 7, 15, 72,
};
3. Separar la inicialización de cada estructura por un par de
llaves.
static struct fecha nacimientos[]={ { "Ana" , 5, 24, 66,}
{ "Jose", 12, 30, 73,} { "Raúl", 7, 15, 72,}};
Referencia a los miembros de una estructura
• Los miembros individuales de una estructura se referencian
utilizando el operador punto (.) y se pueden procesar de la misma manera que las variables ordinarias.
1. Cliente es una variable de tipo cuenta y clientes[100] es un
arreglos de 100 estructuras.
struct cuenta cliente,
clientes[100];
2. Acceso a los campos individuales de la estructura cliente.
cliente.nombre = "Jose";
cliente.saldo = 1000;
3. Acceso al campo ultimo_pago de cliente. (La referencia se
hace desde la estructura más externa a la más interna).
cliente.ultimo_pago.mes;
Acceder al numero de cuenta del cliente 25.
clientes[24].no_cuenta ;
clientes[24].saldo ;
Operación de Asignación
• En algunas versiones antiguas de C, las estructuras debían ser
procesadas campo a campo y la única operación permisible con la estructura completa era tomar su dirección.
• Sin embargo las nuevas versiones de C, incluso el nuevo
ANSI, permiten asignar una estructura completa a otra del mismo composición.
struct cuenta cliente1, cliente2; ......
cliente2 = cliente1;
Operación de asignación.
1. Declaración de dos variables 2. cliente1 ha sido inicializada. 3. Se copian todos los campos.
Programación Estructurada
Tipos definidos por el usuario
• La instrucción typedef permite a los usuarios definir nuevos
tipos de datos que san equivalentes a los tipos existentes, es decir darle nuevos nombre a los tipos existentes.
• Sintaxis: typedef tipo nuevo_tipo;
• donde tipo es el tipo existente y nuevo_tipo es el nuevo
nombre.
• La definición de un nuevo tipo de dato no reemplaza al
anterior, sino añade un nuevo nombre y con lo cual, ambos nombres se pueden usar para declarar variables.
typedef int edad;
edad bebe, joven, adulto;
typedef float altura[100]; altura hombre, mujeres;
Tipos definidos por el usuario
• La instrucción typedef es particularmente útil cuando se
definen estructuras ya que elimina la necesidad de escribir repetidamente la palabra calve struct.
Sintaxis: typedef struct {
tipo1 miembro1; tipo2 miembro2;
...................
tipoN miembroN;
} nuevo_tipo;
• donde nuevo_tipo es el tipo de la estructura definida por el
usuario. Las variables pueden definirse en términos del nuevo tipo de datos.
Tipos definidos por el usuario
1. Declaración de un tipo estructura llamado fecha.
typedef struct {
int mes;
int dia;
int anio; }fecha ;
2. Declaración de un tipo estructura llamado Registro ( Notar que contiene
el nuevo tipo fecha).
typedef struct {
int numero_cuenta;
char tipo_cuenta; char nombre[30];
float saldo;
fecha ultimo_pago;
}registro;
3. Declaración de un arreglo.
registro clientes[100];
Paso de estructuras a funciones
• Se pueden transferir los campos individuales o las estructuras
completas.
• Cuando se pasan campos individuales de una estructura a una
función, el manejo es idéntico a las variables ordinarias.
• El paso de los valores se puede hacer por valor o por
referencia.
1. prototipo de funciones.
void fun1(float );
void fun2(float *);
2. Declaración de una variable cliente.
registro cliente;
3. Llamada por valor.
fun1(clinte.saldo);
4. Llamada por referencia.
fun2(&cliente.saldo);
Paso de estructuras a funciones
• Se permite una transferencia por valor e incluso una función
puede devolver mediante la instrucción return una
estructura; (Notar el contraste de con los arreglos, que no pueden ser pasados por valor ni se devuelven mediante la instrucción return).
1. la definición de registro debe ser visible.
typedef struct {
char nombre[20];
int no_cuenta;
float saldo; } registro;
2. Prototipo de funciones.
void fun1(registro *pt);
void fun2(registro cliente);
registro fun3(void);
Paso de estructuras a funciones
3. Declaración de una variable cliente1 y cliente2.
registro cliente1, cliente2 = {"Jose", 1200, 120.000}; ....
4. Llamada por referencia.
fun1(&cliente2);
5. Llamada por valor.
fun2(cliente2);
6. La función devuelve una estructura
cliente1 = fun3();
Lihat lebih banyak...
Comentários
