Ejemplo 11.

1
struct complejo
{
float x,y;
};
struct racional
{
int numerador;
int denominador;
};
struct fecha
{
unsigned int mes, dia, anyo;
};
struct tiempo
{
unsigned int horas, minutos;
};
struct direccion
{
char calle[40];
int num;
int codpost;
char ciudad [20];
}
struct entrada
{
char nombre[50];
struct direccion dir;
char telefonos [5][15];
};
struct entrada pepe;
printf (La calle donde vive es: %s\n, pepe.dir.calle);

Ejemplo 11.2
union arg
{
int v;
char c[2];
} n;
printf (Introduzca un nmero entero:);

scanf (%d, &n.v);

printf (La mitad ms significativa del nmero es %i \n, c[1]);
printf (La mitad menos significativa del nmero es %i \n, c[0]);
/* En algunos sistemas puede ser al revs */
Ejemplo 11.3
enum tipo_operacion {deposito, retirada, aldia, estado};
enum tipo_operacin op;
...
switch (op)
{
case deposito: realizar_deposito (args);
break;
case aldia: poner_al_dia (args);
break;
case retirada: retirar_fondos (args);
break;
case estado: imprimir_estado (args);
break;
default: imprimir_error (args);
}

Ejemplo 11.4

Uso de typedef para declarar un nuevo nombre, Longitud, de tipo de dato double.
typedef double Longitud;

Ejemplo 11.6
struct entrada
{
char nombre[50];
struct direccion dir;
char telefonos [5][15];
int edad;
int sexo:1; /* H: 1 M: 0 */
int departamento:3; /* codigo <8 */
int contrato:3;
};

PROBLEMAS RESUELTOS
11.1.
Es necesario conservar la palabra struct en la declaraciones de variables, a no ser que se
aada una sentencia de tipo typedef como la siguiente:

typedef struct hormiga hormiga;

11.2
enum estaciones {PRIMAVERA =1, VERANO=2, INVIERNO=3, OTONO=4};

11.3
enum estaciones leerEstacion ( )
{
int e;
printf(Introduzca el nmero de la estacin del ao:
printf( 1 Primavera\n);
printf( 2 Verano\n);
printf( 3 Otoo\n);
printf( 4 Invierno\n);
scanf(%d, &e);
switch (e)
{
case 1: return (PRIMAVERA); break;
case 2: return (VERANO); break;
case 3: return (OTOO); break;
case 4: return (INVIERNO); break;
default: printf (Entrada errnea \n); return;
}
}

11.4
enum meses {ENERO=1, FEBRERO=2, MARZO=3, ABRIL=4, MAYO=5,
JUNIO=6, JULIO=7, AGOSTO=8, SEPTIEMBRE=9,
OCTUBRE=10, NOVIEMBRE=11, DICIEMBRE=12};

11.5
La incializacin de una estructura puede hacerse solamente cuando es
esttica o global. No se puede definir un array de caracteres sin especificar
el tamao. La mayor parte de los compiladores tampoco permite inicializar
las estructuras de la manera que aparece en el ejemplo fuera de la
inicializacin de variables globales. Para estar seguros habra que inicializar
la estructura fecha miembro a miembro.

11.6
La sentencia no aade ningn tipo de datos nuevo a los ya definidos en el lenguaje C.
Simplemente permite renombrar un tipo ya existente, incluso aunque sea un nuevo nombre para
un tipo de datos bsico del lenguaje como int o char.
11.7

struct alumno
{
char nombre [40];
int curso;
int edad;
char direccion[40];
int notas[10];
};
struct profesor {
char nombre [40];
char direccion[40];
char asignaturas[10][20];
};
union univ {
struct alumno al;
struct profesor prof;
};

11.8
struct alumno a;
struct profesor p;
union univ un;

11.9
struct alumno leerAlumno( )
{
struct alumno aa;
int i;
printf( Introduzca el nombre \n);
scanf(%s, aa.nombre);
printf( Introduzca la edad \n);
scanf(%d, &aa.edad);
printf( Introduzca su curso \n);
scanf(%d, &aa.curso);
printf( Introduzca la direccin\n);
scanf(%s, aa.direccion);
for (i=1; i<10; i++)
{
printf( Introduzca la nota de la asignatura %d \n, i);
scanf(%d, &aa.notas[i]);
}
return aa;
}

11.10
leerAlumno(struct alumno *aa)
{
int i;
printf( Introduzca el nombre \n);
scanf(%s, aa->nombre);
printf( Introduzca la edad \n);
scanf(%d, &aa->edad);

printf( Introduzca su curso \n);

scanf(%d, &aa->curso);
printf( Introduzca la direccin\n);
scanf(%s, aa->direccion);
for (i=1; i<10; i++)
{
printf( Introduzca la nota de la asignatura %d \n, i);
scanf(%d, &aa->notas[i]);
}
}

11.11
mostrarAlumno(struct alumno *aa)
{
int i;
printf( Nombre: %s\n, aa->nombre );
printf( Edad: %d \n, aa->edad);
printf( Curso: %d\n, aa->curso);
printf( Direccin: %s\n, aa->direccion);
for (i=1; i<10; i++)
printf( Nota de la asignatura %d: %d \n, i, aa->notas[i]);
}

11.12
struct cliente
{
char nombre[100];
int numUnidades;
float precio;
char estado;
};
main( )
{
struct cliente listado [100];
for (i=0; i<100; i++)
{
printf(Introduzca nombre del cliente: );
scanf(%s,listado[i].nombre);
printf(\n Introduzca el nmero de unidades solicitadas: );
scanf(%d,listado[i].numUnidades);
printf(\n Introduzca el precio de cada unidad:);
scanf(%f,listado[i].precio);
printf(\n Introduzca el estado del cliente (m\a\p));
scanf(%c,listado[i].estado);
}
}

11.13
for (i=0; i<100; i++)
{
if (listado[i].estado == m)

printf (%s\n,listado[i].nombre);
}
for (i=0; i<100; i++)
{
if (listado[i].estado == p)
if (listado[i].precio * listado[i].numUnidades > maximo)
printf (%s\n,listado[i].nombre);
}

11.14
struct complejo
{
float r;
float i;
};
struct complejo suma (struct complejo a, struct complejo b)
{
struct complejo c;
c.r = a.r + b.r;
c.i = a.i + b.i;
return c;
}
struct complejo resta (struct complejo a, struct complejo b)
{
struct complejo c;

c.r = a.r - b.r;

c.i = a.i - b.i;
return c;

struct complejo multiplicacion (struct complejo a, struct complejo b)

{
struct complejo c;
c.r = a.r*b.r - a.i*b.i;
c.i = a.r*b.i + a.i*b.r;
return c;
}

11.15
struct racional
{
float num;
float denom;
};
main( )
{
struct racional a,b,c;
printf ("Introduzca dos nmeros racionales con el formato
x/y.\n");

scanf ("%f/%f", &a.num, &a.denom);

scanf ("%f/%f", &b.num, &b.denom);
sumar (a,b,&c);
printf ("La suma de ambos nmeros es: %f/%f.\n", c.num, c.denom);
restar (a,b,&c);
printf ("La resta de ambos nmeros es: %f/%f.\n", c.num, c.denom);
multiplicar (a,b,&c);
printf ("El producto de ambos nmeros es: %f/%f.\n", c.num,
c.denom);
dividir (a,b,&c);
printf ("La divisin de ambos nmeros es: %f/%f.\n", c.num,
c.denom);
}
void sumar (struct racional x, struct racional y, struct racional *z)
{
z->num = x.num + y.num;
z->denom = x.denom + y.denom;
}
void restar (struct racional x, struct racional y, struct racional *z)
{
z->num = x.num - y.num;
z->denom = x.denom - y.denom;
}
void multiplicar (struct racional x, struct racional y, struct
racional *z)
{
z->num = x->num * y->num;
z->denom = x->denom * y->denom;
}
void dividir (struct racional x, struct racional y, struct racional
*z)
{
z->num = x->num * y->denom;
z->denom = x->denom * y->num;
}

11.16
struct baloncesto
{
char nombre[20];
int victorias;
int derrotas;
int perdidas;
int rebotes;
char mejorTriples [40];
int triples;
};
struct futbol
{
char nombre[20];
int victorias;
int derrotas;
int empates;

};

int golesAFavor;
int golesContra;
int golesGoleador;
char goleador[40];

main( )
{
struct baloncesto equiposB [10];
struct futbol equiposF [10];
int i;
for (i=0, i<10; i++) leerEquipoBaloncesto (&equiposB[i]);
for (i=0, i<10; i++) leerEquipoFutbol (&equiposF[i]);
}
void leerEquipoBaloncesto ( struct baloncesto *bal)
{
printf ("\n\tItroducir nombre del equipo :");
scanf("%s",bal->nombre);
printf ("\n\tItroducir el nmero de victorias conseguidas :");
scanf ("%d", &bal->victorias);
printf ("\n\tItroducir el nmero de derrotas :");
scanf ("%d", &bal->derrotas);
printf ("\n\tItroducir el nmero de prdidas de baln :");
scanf ("%d", &bal->perdidas);
printf ("\n\tItroducir el nmero de rebotes cogidos :");
scanf ("%d", &bal->rebotes);
printf ("\n\tItroducir nombre del mejor triplista :");
scanf("%s", bal->mejorTriples);
printf ("\n\tItroducir el nmero de rebotes cogidos :");
scanf ("%d", &bal->triples);
}
void leerEquipoFutbol ( struct baloncesto *fut)
{
printf ("\n\tItroducir nombre del equipo :");
scanf("%s", fut->nombre);
printf ("\n\tItroducir el nmero de victorias conseguidas :");
scanf ("%d", &fut->victorias);
printf ("\n\tItroducir el nmero de derrotas :");
scanf ("%d", &fut->derrotas);
printf ("\n\tItroducir el nmero de empates :");
scanf ("%d", &fut->empates);
printf ("\n\tItroducir el nmero de goles a favor :");
scanf ("%d", &fut->golesAFavor);
printf ("\n\tItroducir el nmero de goles en contra :");
scanf ("%d", &fut->golesContra);
printf ("\n\tItroducir nombre del mejor goleador :");
scanf("%s", fut->goleador);
printf ("\n\tItroducir el nmero de goles del goleador :");
scanf ("%d", &fut->golesGoleador);
}

11.17
mejoresTriplistas ( struct baloncesto *listado)
{
int i;

for (i=0, i<10; i++)

printf ("El mejor triplista del equipo %s",
listado[i].nombre);
printf (" es : %s \n", listado[i].mejortriples);
}
maximoGoleador ( struct futbol *listado)
{
int i, imax, maxgol=0;
for (i=0; i<10; i++)
if (listado[i].golesGoleador > maxgol)
{
maxgol = listado[i].golesGoleador;
imax = i;
}
printf ("El mximo goleador de la liga ha sido %s\n",
listado[imax].goleador);
}
equipoGanadorFutbol (struct futbol *listado)
{
int i, imax, maxptos=0, ptos;
for (i=0; i<10; i++)
{
ptos=listado[i].victorias *3 + listado[i].empates;
if (ptos > maxptos)
{
maxptos = ptos;
imax = i;
}
}
printf ("El equipo ganador de la liga ha sido el %s\n",
listado[imax].nombre);
}
equipoGanadorBaloncesto (struct baloncesto *listado)
{
int i, imax, maxptos=0, ptos;
for (i=0; i<10; i++)
{
ptos=listado[i].victorias;
if (ptos > maxptos)
{
maxptos = ptos;
imax = i;
}
}
printf ("El equipo ganador de la liga ha sido el %s\n",
listado[imax].nombre);
}

11.18
struct punto
{
float x;
float y;

};
main( )
{
struct punto p, q, r;
printf ("Introduzca las coordenadas de dos puntos. \n");
printf ("Primer punto. Coordenada x:");
scanf ("%f", &p.x);
printf ("\n Primer punto. Coordenada y:");
scanf ("%f", &p.y);
printf ("\n Segundo punto. Coordenada x:");
scanf ("%f", &q.x);
printf ("\n Segundo punto. Coordenada y:");
scanf ("%f", &q.y);
printf ("\n La distancia entre ambos puntos es de %f.\n,
distancia (p, q));
medio (p,q, &r);
printf (El punto medio de la recta que une ambos puntos es: (%f,
%f). \n", r.x, r.y);
}
float distancia (struct punto p1, struct punto p2)
{
return (sqrt( sqr( p1.x-p2.y), sqr( p1.x-p2.y)));
}
medio (struct punto p1, struct punto p2, struct punto * p3)
{
p3->x = (p1->x + p2->x) /2 ;
p3->y = (p1->y + p2->y) /2 ;
}

11.19
#include
#include
#include
#include

<stdio.h>
<stdlib.h>
<string.h>
<ctype.h>

#define ULTIMO_CAR(s) (((char *)s)[strlen(s) - 1])

#define max(x,y) (((x) >= (y)) ? (x) : (y))
typedef enum {Error_ = -1, Exito_, Falso_ = 0, Verdadero_} Booleano;
int buftam;
struct
{
char patron[40];
int numbytes;
} busqueda[40];

/* patrn a buscar
/* longitud de patrn

int main (int argc, char *argv[])

{
int bytes, n, modificado;
FILE *fp = NULL;
char *buf = NULL, *p, *ptr;
fpos_t rpos, wpos;
int i, patrones, max_bytes = 0, j;

*/
*/

if (2 > argc)
/* no hay fichero */
return 1;
if (3 > argc)
/* faltan argumentos */
return 2;
if (NULL == (fp = fopen(argv[1], "r+b")))
return 3;
/* error de apertura de fichero */
if (NULL == (buf = getbuf( )))
return 4;
/* no hay memoria para el buffer */
patrons = argc - 2;
/* argumentos a procesar */
for (i = 2; i < argc; ++i)
{
if (NULL != (ptr = strtok(argv[i], ",")))
{
p = busqueda[i - 2].patron;
do
{
busqueda[i - 2].numbytes++;
if (1 == strlen(ptr))
{
*p++ = *ptr;
continue;
}
switch (toupper(ULTIMO_CAR(ptr)))
{
case 'D': ULTIMO_CAR (ptr) = '\0';
*p++ = (char)atoi(ptr);
break;
case 'H': ULTIMO_CAR (ptr) = '\0';
if (Error_ == hex2char(ptr, p++))
return 5;
break;
default: return 5;
}
} while (NULL != (ptr = strtok(NULL, ",")));
*p = '\0';
max_bytes = max(max_bytes, bsqueda[i - 2].numbytes);
}
else return 5;
}
fgetpos(fp, &rpos);/* guardar la posicin en que estamos */
while (1)
{
if (max_bytes > (bytes = (int)fread(buf, 1, bufsize, fp)))
{
if (0 == bytes && !feof(fp))
return 6;
/* algo no marcha!
*/
else break;
/* hecho!
*/
}
for (n = 0, modificado = Falso_; n < patrones; ++n)
{
/* comprobar cada patron */
for (i = 0; i < (bytes - max_bytes + 1); ++i)
{
if (buf[i] != *(busqueda[n].patron))
continue;
if (Exito_ != strncmp(&buf[i],
busqueda[n].patron, busqueda[n].numbytes))
continue;
for (j = 0; j < busqueda[n].numbytes; ++j, ++i)
buf[i] = '\0';

modificado = Verdadero_;
}

}
if (modificado) /* escribir los cambios, si hay*/
{
wpos = rpos;
fsetpos(fp, &wpos);
if (bytes != (int)fwrite(buf, 1, bytes, fp))
return 7;
fsetpos(fp, &rpos);
}
rpos += bytes - max_bytes + 1;
fsetpos(fp, &rpos);

}
fclose(fp);
return Exito_;

char *getbuf(void)
{
register char *buffer;
for (buftam = 0x4000; bufsize >= 128; bufsize >>= 1)
{
if (NULL != (buffer = (char *) malloc(bufsize)))
return buffer;
}
return NULL;

#define xdigit(c) (toupper(c) - (((c) > '9') ? 'A' - 10 : '0'))

Booleano hex2char(const char *hex, char *buf)
{
int ch = 0;
char *p = (char *)hex;
while(*p)
{
if (!isxdigit(*p))
return Error_;
ch <<= 4;
ch += xdigit(*p);
++p;
}
*buf = (char)ch;
return Exito_;
}

11.20.
char *inet_l2a (long int d)
{
union
{
long int l;
char bytes[4];
} u;
char dir = (char*) malloc (16);

u.l = d;
sprintf (dir, "%i.%i.%i.%i", u.bytes[0], u.bytes[1],
u.bytes[2],u.bytes[3], );
return dir;
}