Alias Typedel
Alias Typedel
Alias Typedel
existentes (typedef)
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>
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:
entero edad1,edad2;
Tener en cuenta que en edad1 y edad2 se pueden guardar valores de tipo int.
La declaración de tipos tiene por objetivo hacer que nuestro programa sea más legible.
Problema 1:
NuevosNombresTypedef.c
#include<stdio.h>
#include<conio.h>
typedef struct {
int codigo;
char descripcion[41];
float precio;
} tproducto;
void presentacion()
{
printf("\n");
printf(" Declarar un registro que permita almacenar el codigo, descripcion y precio de un producto.\
n");
printf(" Crear un alias para dicho tipo.\n");
printf(" Definir dos variables, cargarlas e imprimir el nombre del producto que tiene mayor precio.\
n");
printf(" Muestra 3 Funciones mas Presentacion, Separacion y Finalizacion.\n");
printf("\n");
printf("*******************************\n");
}
void separacion()
{
printf("\n*******************************\n");
}
void finalizacion()
{
printf("\n*******************************\n");
printf("\n-------------------------------------------------------------------------\n");
printf(" Muchas Gracias por ejecutar este programa");
printf("\n-------------------------------------------------------------------------\n");
printf(" \n Juan Carlos Gonzalez \n");
printf("\n*******************************\n");
}
int main()
{
presentacion();
separacion();
printf("\n");
tproducto pro1,pro2;
printf("\n-------------------------------------------------------------------------\n");
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("\n-------------------------------------------------------------------------\n");
if (pro1.precio>pro2.precio)
{
printf("\n-------------------------------------------------------------------------\n");
printf(" El producto %s tiene un precio mayor",pro1.descripcion);
printf("\n-------------------------------------------------------------------------\n");
}
else
{
if (pro2.precio>pro1.precio)
{
printf("\n-------------------------------------------------------------------------\n");
printf( " El producto %s tiene un precio mayor",pro2.descripcion);
printf("\n-------------------------------------------------------------------------\n");
}
else
{
printf("\n-------------------------------------------------------------------------\n");
printf(" Tienen igual precio");
printf("\n-------------------------------------------------------------------------\n");
}
}
separacion();
finalizacion();
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;
struct {
int codigo;
char descripcion[41];
float precio;
}
tproducto pro1,pro2;
NuevosNombresTypedef2.c
#include<stdio.h>
#include<conio.h>
struct producto{
int codigo;
char descripcion[41];
float precio;
};
void presentacion()
{
printf("\n");
printf(" Declarar un registro que permita almacenar el codigo, descripcion y precio de un producto.\
n");
printf(" Crear un alias para dicho tipo.\n");
printf(" Definir dos variables, cargarlas e imprimir el nombre del producto que tiene mayor precio.\
n");
printf(" Muestra 3 Funciones mas Presentacion, Separacion y Finalizacion.\n");
printf("\n");
printf("*******************************\n");
}
void separacion()
{
printf("\n*******************************\n");
}
void finalizacion()
{
printf("\n*******************************\n");
printf("\n-------------------------------------------------------------------------\n");
printf(" Muchas Gracias por ejecutar este programa");
printf("\n-------------------------------------------------------------------------\n");
printf(" \n Juan Carlos Gonzalez \n");
printf("\n*******************************\n");
}
int main()
{
presentacion();
separacion();
tproducto pro1,pro2;
printf("\n");
printf("\n-------------------------------------------------------------------------\n");
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("\n-------------------------------------------------------------------------\n");
if (pro1.precio>pro2.precio)
{
printf("\n-------------------------------------------------------------------------\n");
printf(" El producto %s tiene un precio mayor",pro1.descripcion);
printf("\n-------------------------------------------------------------------------\n");
}
else
{
if (pro2.precio>pro1.precio)
{
printf("\n-------------------------------------------------------------------------\n");
printf(" El producto %s tiene un precio mayor",pro2.descripcion);
printf("\n-------------------------------------------------------------------------\n");
}
else
{
printf("\n-------------------------------------------------------------------------\n");
printf(" Tienen igual precio");
printf("\n-------------------------------------------------------------------------\n");
}
}
separacion();
finalizacion();
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:
tproducto pro1,pro2;
Problema 2:
NuevosNombresTypedef3.c
#include<stdio.h>
#include<conio.h>
#define TAM 5
struct persona {
char nombre[40];
int edad;
};
void presentacion()
{
printf("\n");
printf(" Crear vector de 5 elementos con componentes tipo registro almacenen el nombre de una
persona y su edad.\n");
printf(" Crear un alias para dicho tipo.\n");
printf(" Muestra 3 Funciones mas Presentacion, Separacion y Finalizacion.\n");
printf("\n");
printf("*******************************\n");
}
for(f=0;f<TAM;f++)
{
printf("\n");
printf("-------------------------------------------------------------------------\n");
printf(" Ingrese el nombre: ");
gets(personas[f].nombre);
printf(" Ingrese la edad: ");
scanf("%i",&personas[f].edad);
fflush(stdin);
}
}
void separacion()
{
printf("\n*******************************\n");
}
void finalizacion()
{
printf("\n*******************************\n");
printf("\n-------------------------------------------------------------------------\n");
printf(" Muchas Gracias por ejecutar este programa");
printf("\n-------------------------------------------------------------------------\n");
printf(" \n Juan Carlos Gonzalez \n");
printf("\n*******************************\n");
}
int main()
{
presentacion();
separacion();
tpersonas personas;
cargar(personas);
printf("\n-------------------------------------------------------------------------\n");
imprimir(personas);
separacion();
finalizacion();
getch();
return 0;
}
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":
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;
};
NuevosNombresTypedef4.c
#include<stdio.h>
#include<conio.h>
#include<stdlib.h>
struct nodo {
int info;
struct nodo *sig;
};
void presentacion()
{
printf("\n");
printf(" Confeccionar una programa que administre una lista tipo pila.\n");
printf(" Crear un alias para dicho tipo.\n");
printf(" Se debe poder insertar, extraer e imprimir los datos de la pila.\n");
printf(" Muestra 3 Funciones mas Presentacion, Separacion y Finalizacion.\n");
printf("\n");
printf("*******************************\n");
}
void insertar(int x)
{
tnodo nuevo;
nuevo = malloc(sizeof(struct nodo)); //reservamos espacio para el nodo
nuevo->info = x;
void imprimir()
{
tnodo reco=raiz;
printf("-------------------------------------------------------------------------\n");
printf(" Lista completa.\n");
printf("-------------------------------------------------------------------------\n");
while (reco!=NULL)
{
printf("%3i ",reco->info);
reco=reco->sig;
}
printf("\n");
}
int extraer()
{
if (raiz != NULL) //si la raiz no esta vacia
{
int informacion = raiz->info;
tnodo bor = raiz;
raiz = raiz->sig;
free(bor);
return informacion;
}
else
{
return -1;
}
}
void liberar()
{
tnodo reco = raiz;
tnodo bor;
void separacion()
{
printf("\n*******************************\n");
}
void finalizacion()
{
printf("\n*******************************\n");
printf("\n-------------------------------------------------------------------------\n");
printf(" Muchas Gracias por ejecutar este programa");
printf("\n-------------------------------------------------------------------------\n");
printf(" \n Juan Carlos Gonzalez \n");
printf("\n*******************************\n");
}
int main()
{
presentacion();
separacion();
insertar(10);
insertar(40);
insertar(3);
imprimir();
printf("-------------------------------------------------------------------------\n");
printf(" Extraemos de la pila: %i\n",extraer());
imprimir();
liberar();
separacion();
finalizacion();
getch();
return 0;
}
Ahora estamos viendo lo que cambia si introducimos la creación de alias mediante la palabra reservada
typedef.
struct nodo {
int info;
struct nodo *sig;
};
Con la palabra typedef definimos un alias llamado "tnodo" que es de tipo "struct nodo *":
tnodo nuevo;
Estamos realmente definiendo un puntero a tipo nodo, esto debido a que tnodo es un alias de dicho tipo:
Si consultamos el código fuente del sistema operativo Linux en muchos de sus archivos encontraremos el
uso de typedef: