En el lenguaje C existen muchos tipos de datos primitivos (int, char, float etc.) y estructuras de datos.
Mediante la palabra clave typedef podemos definir un alias para un tipo de dato existente:
#include<stdio.h>
#include<conio.h>
typedef int entero;
int main()
{
entero edad1,edad2;
edad1=5;
edad2=7;
printf("Las edades son :%i y %i",edad1,edad2);
getch();
return 0;
}
La sintaxis para declarar un nuevo nombre para un tipo de dato existente es indicar luego de la palabra clave typedef el tipo de dato y el nuevo nombre:
typedef int entero;
Luego de esta declaración podemos definir variables de tipo entero:
entero edad1,edad2;
Tener en cuenta que en edad1 y edad2 se pueden guardar valores de tipo int.
Decimos que el nombre "entero" es un alias del tipo de dato "int".
La declaración de tipos tiene por objetivo hacer que nuestro programa sea más legible.
typedef con struct.
Podemos declarar un alias para un tipo de dato registro.
Problema 1:
Declarar un registro que permita almacenar el código, descripción y precio de un producto. Crear un alias para dicho tipo. Definir dos variables, cargarlas e imprimir el nombre del producto que tiene mayor precio.
Programa: programa208.c
#include<stdio.h>
#include<conio.h>
typedef struct {
int codigo;
char descripcion[41];
float precio;
} tproducto;
int main()
{
tproducto pro1,pro2;
printf("Ingrese el codigo del producto:");
scanf("%i",&pro1.codigo);
fflush(stdin);
printf("Ingrese la descripcion:");
gets(pro1.descripcion);
printf("Ingrese el precio:");
scanf("%f",&pro1.precio);
printf("Ingrese el codigo del producto:");
scanf("%i",&pro2.codigo);
fflush(stdin);
printf("Ingrese la descripcion:");
gets(pro2.descripcion);
printf("Ingrese el precio:");
scanf("%f",&pro2.precio);
if (pro1.precio>pro2.precio)
{
printf("El producto %s tiene un precio mayor",pro1.descripcion);
}
else
{
if (pro2.precio>pro1.precio)
{
printf("El producto %s tiene un precio mayor",pro2.descripcion);
}
else
{
printf("Tienen igual precio");
}
}
getch();
return 0;
}
La sintaxis para declarar un alias para un struct es similar a la vista en el ejemplo anterior:
typedef struct {
int codigo;
char descripcion[41];
float precio;
} tproducto;
En este ejemplo "tproducto" es un alias del registro:
struct {
int codigo;
char descripcion[41];
float precio;
}
La sintaxis para definir una variable de tipo "tproducto" es:
tproducto pro1,pro2;
No debemos anteceder la palabra clave struct.
Otra sintaxis alternativa para resolver el problema anterior es:
Programa: programa209.c
#include<stdio.h>
#include<conio.h>
struct producto{
int codigo;
char descripcion[41];
float precio;
};
typedef struct producto tproducto;
int main()
{
tproducto pro1,pro2;
printf("Ingrese el codigo del producto:");
scanf("%i",&pro1.codigo);
fflush(stdin);
printf("Ingrese la descripcion:");
gets(pro1.descripcion);
printf("Ingrese el precio:");
scanf("%f",&pro1.precio);
printf("Ingrese el codigo del producto:");
scanf("%i",&pro2.codigo);
fflush(stdin);
printf("Ingrese la descripcion:");
gets(pro2.descripcion);
printf("Ingrese el precio:");
scanf("%f",&pro2.precio);
if (pro1.precio>pro2.precio)
{
printf("El producto %s tiene un precio mayor",pro1.descripcion);
}
else
{
if (pro2.precio>pro1.precio)
{
printf("El producto %s tiene un precio mayor",pro2.descripcion);
}
else
{
printf("Tienen igual precio");
}
}
getch();
return 0;
}
Primero declaramos un tipo de dato registro como hemos visto en muchos conceptos anteriores:
struct producto{
int codigo;
char descripcion[41];
float precio;
};
Luego creamos un alias para dicho tipo de dato registro mediante la palabra clave typedef:
typedef struct producto tproducto;
Para definir registros ahora lo podemos hacer con la sintaxis:
tproducto pro1,pro2;
O con la sintaxis que ya conocíamos:
struct producto pro1,pro2;
typedef con struct y array
Podemos declarar un alias para un tipo de dato de array de registros
Problema 2:
Definir un alias de un vector de 5 elementos con componentes de tipo registro que almacenen el nombre de una persona y su edad .
Programa: programa210.c
#include<stdio.h>
#include<conio.h>
#define TAM 5
struct persona {
char nombre[40];
int edad;
};
typedef struct persona tpersonas[TAM];
void cargar(tpersonas personas)
{
int f;
for(f=0;f<TAM;f++)
{
printf("Ingrese el nombre:");
gets(personas[f].nombre);
printf("Ingrese la edad:");
scanf("%i",&personas[f].edad);
fflush(stdin);
}
}
void imprimir(tpersonas personas)
{
int f;
for(f=0;f<TAM;f++)
printf("%s %i\n",personas[f].nombre,personas[f].edad);
}
int main()
{
tpersonas personas;
cargar(personas);
imprimir(personas);
getch();
return 0;
}
Declaramos un registro de tipo persona con dos campos:
struct persona {
char nombre[40];
int edad;
};
Ahora mediante la palabra clave typedef definimos un alias para un "struct persona" e indicamos entre corchetes al final que es un vector de tamaño "TAM":
typedef struct persona tpersonas[TAM];
Cuando definimos una variable de tipo tpersona en realidad estamos definiendo un vector de tamaño "TAM" y con componentes de tipo "struct persona":
int main()
{
tpersonas personas;
Problema 3:
Confeccionar una programa que administre una lista tipo pila (se debe poder insertar, extraer e imprimir los datos de la pila).
La estructura del nodo es la siguiente:
struct nodo {
int info;
struct nodo *sig;
};
Luego se crea un alias para tipo de dato puntero a nodo:
typedef struct nodo * tnodo;
Programa: programa211.c
#include<stdio.h>
#include<conio.h>
#include<stdlib.h>
struct nodo {
int info;
struct nodo *sig;
};
typedef struct nodo * tnodo;
//variable global que apunta al primer nodo de la lista
tnodo raiz=NULL;
void insertar(int x)
{
tnodo nuevo;
nuevo = malloc(sizeof(struct nodo));
nuevo->info = x;
if (raiz == NULL)
{
raiz = nuevo;
nuevo->sig = NULL;
}
else
{
nuevo->sig = raiz;
raiz = nuevo;
}
}
void imprimir()
{
tnodo reco=raiz;
printf("Lista completa.\n");
while (reco!=NULL)
{
printf("%i ",reco->info);
reco=reco->sig;
}
printf("\n");
}
int extraer()
{
if (raiz != NULL)
{
int informacion = raiz->info;
tnodo bor = raiz;
raiz = raiz->sig;
free(bor);
return informacion;
}
else
{
return -1;
}
}
void liberar()
{
tnodo reco = raiz;
tnodo bor;
while (reco != NULL)
{
bor = reco;
reco = reco->sig;
free(bor);
}
}
int main()
{
insertar(10);
insertar(40);
insertar(3);
imprimir();
printf("Extraemos de la pila:%i\n",extraer());
imprimir();
liberar();
getch();
return 0;
}
Este problema ya lo resolvimos conceptos anteriores cuando vimos estructuras dinámicas. Ahora estamos viendo lo que cambia si introducimos la creación de alias mediante la palabra reservada typedef.
La definición del nodo no cambia con lo visto anteriormente:
struct nodo {
int info;
struct nodo *sig;
};
Con la palabra typedef definimos un alias llamado "tnodo" que es de tipo "struct nodo *":
typedef struct nodo * tnodo;
Ahora cuando definimos una variable de tipo "tnodo":
tnodo nuevo;
Estamos realmente definiendo un puntero a tipo nodo, esto debido a que tnodo es un alias de dicho tipo:
struct nodo * nuevo;
Si consultamos el código fuente del sistema operativo Linux en muchos de sus archivos encontraremos el uso de typedef:
