65 - Definición de nuevos nombres para tipos de datos

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>

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.

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");

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);
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;

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:

NuevosNombresTypedef2.c
#include<stdio.h>
#include<conio.h>

struct producto{
int codigo;
char descripcion[41];
float precio;
};

typedef struct producto tproducto; //struc producto se sustituira por 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();

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");

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);
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:

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 .

NuevosNombresTypedef3.c
#include<stdio.h>
#include<conio.h>

#define TAM 5

struct persona {
char nombre[40];
int edad;
};

typedef struct persona tpersonas[TAM]; //struc persona se sustituira por tpersonas

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");
}

void cargar(tpersonas personas)

{
int f;

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 imprimir(tpersonas personas)

{
int f;
printf(" El Nombre y la Edad de las Personas: \n");
printf("-------------------------------------------------------------------------\n");
for(f=0;f<TAM;f++)
printf(" %10s - %2i\n",personas[f].nombre,personas[f].edad);
}

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;
}

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;

NuevosNombresTypedef4.c
#include<stdio.h>
#include<conio.h>
#include<stdlib.h>

struct nodo {
int info;
struct nodo *sig;
};

typedef struct nodo * tnodo; //struc nodo se sustituira por tnodo

tnodo raiz=NULL; //variable global que apunta al primer nodo de la lista

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;

if (raiz == NULL) //si la lista esta vacia

{
raiz = nuevo;
nuevo->sig = NULL;
}
else
{
nuevo->sig = raiz;
raiz = nuevo;
}
}

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;

while (reco != NULL)

{
bor = reco;
reco = reco->sig;
free(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;
}

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: