¿Qué está mal en este código?

[eoliTH]

Hola, tengo una pequeña práctica para clase (aún sin acabar) pero ya
tengo una parte completa que debería funcionar y no funciona...La cosa
es que compila con el compilador de Borland (el de las herramientas en
línea de comandos que se pueden descargar gratuitamente de
community.borland.com) pero no funciona muy bien que digamos. Da algunos
errores "de memoria", como por ejemplo en la función NuevoEmp() que se
encuentra en el fichero bd.h, más concretamente al introducir el campo
"nombre". Por favor si veis fallos o si tenéis comentarios o consejos,
os agradecería que los pusierais. Aquí va el programa:

/*********** Empieza el archivo bdejempl.c *****************/
#include "bd.h"

void menu(empleado *emp1,dpto *dpto1,zona *zona1,lleva_zonas *lleva_zonas1);

int main () {
empleado *emp1=NULL;
dpto *dpto1=NULL;
zona *zona1=NULL;
lleva_zonas *lleva_zonas1=NULL;
menu(emp1,dpto1,zona1,lleva_zonas1);
getch();
return 0;
}
/*********** Termina el archivo bdejempl.c *****************/

/*********** Empieza el archivo bd.h ******************/
#include <stdlib.h>
#include <stdio.h>
#include <conio.h>

/*************** Estructuras ****************/
typedef struct emp {
unsigned int code,codd;
float tlf;
char *nombre,*puesto;
struct emp *sig;
} empleado;

typedef struct dpt {
unsigned int codd;
char *desc,*ubic;
struct dpt *sig;
} dpto;

typedef struct zonas {
unsigned int codz;
char *desc;
struct zonas *sig;
} zona;

typedef struct lleva {
unsigned int codz,code;
struct lleva *sig;
} lleva_zonas;

/**************** Funciones *****************/
void NuevoEmp(empleado *emp1) {
unsigned int code=0;
empleado *aux;
aux=emp1;
while (aux!=NULL) {
code=aux->code;
aux=aux->sig;
}
aux=malloc(sizeof(empleado));
aux->code=code+1;
puts("Nombre:");gets(aux->nombre);
puts("Puesto:");gets(aux->puesto);
puts("Teléfono:");scanf("%g",&(aux->tlf));
puts("Código de dpto.:");scanf("%d",&(aux->codd));
aux->sig=NULL;
}

void NuevoDpto(dpto *dpto1) {
unsigned int codd=0;
dpto *aux;
aux=dpto1;
while (aux!=NULL) {
codd=aux->codd;
aux=aux->sig;
}
aux=malloc(sizeof(dpto));
aux->codd=codd+1;
puts("Descripción:");gets(aux->desc);
puts("Ubicación:");gets(aux->ubic);
aux->sig=NULL;
}

void NuevaZona(zona *zona1) {
zona *aux;
aux=zona1;
while (aux!=NULL) {
aux=aux->sig;
}
aux=malloc(sizeof(zona));
puts("Código de zona:");scanf("%d",&(aux->codz));
puts("Descripción:");gets(aux->desc);
aux->sig=NULL;
}

void NuevoLleva(lleva_zonas *lleva_zonas1,unsigned int codz,unsigned int
code) {
lleva_zonas *aux;
aux=lleva_zonas1;
while (aux!=NULL) {
aux=aux->sig;
}
aux=malloc(sizeof(lleva_zonas));
aux->codz=codz;
aux->code=code;
aux->sig=NULL;
}

/* Empiezan las funciones para ver la tabla Empleados */
void VerEmp1(void) {
printf("%-10s %-20s %-15s %-10s %-10s
\n","Cód.Emp.","Nombre","Puesto","Cód.Dpto","Teléfono");
puts("--------------------------------------------------------------------------------");
}

void VerEmp(empleado *aux) {
printf("%-10d %-20s %-15s %-10d %-10g
\n",aux->code,aux->nombre,aux->puesto,aux->codd,aux->tlf);
}

void VerTablaEmp(empleado *emp1) {
empleado *aux;
aux=emp1;
VerEmp1();
while (aux!=NULL) {
VerEmp(aux);
aux=aux->sig;
}
}
/* Terminan las funciones para ver la tabla Empleados. */

/* Empiezan las funciones para ver la tabla Dptos. */
void VerDpto1(void) {
printf("%-10s %-30s %-30s\n","Cód.Dpto","Descripción","Ubicación");
puts("--------------------------------------------------------------------------------");
}

void VerDpto(dpto *aux) {
printf("%-10d %-30s %-30s\n",aux->codd,aux->desc,aux->ubic);
}

void VerTablaDpto(dpto *dpto1) {
dpto *aux;
aux=dpto1;
VerDpto1();
while (aux!=NULL) {
VerDpto(aux);
aux=aux->sig;
}
}
/* Terminan las funciones para ver la tabla Dptos. */

/* Empiezan las funciones para ver la tabla Zonas */
void VerZona1(void) {
printf("%-10s %-30s\n","Cód.Zona","Descripción");
puts("--------------------------------------------------------------------------------");
}

void VerZona(zona *aux) {
printf("%-10d %-30s\n",aux->codz,aux->desc);
}

void VerTablaZonas(zona *zona1) {
zona *aux;
aux=zona1;
VerZona1();
while (aux!=NULL) {
VerZona(aux);
aux=aux->sig;
}
}
/* Terminan las funciones para ver la tabla Zonas */

/* Empiezan las funciones para ver la tabla LlevaZonas */
void VerLlevaZonas1(void) {
printf("%-12s %-12s\n","Cód.Zona","Cod.Empleado");
puts("--------------------------------------------------------------------------------");
}

void VerLlevaZonas(lleva_zonas *aux) {
printf("%-12d %-12d\n",aux->codz,aux->code);
}

void VerTablaLlevaZonas(lleva_zonas *lleva_zonas1) {
lleva_zonas *aux;
aux=lleva_zonas1;
VerLlevaZonas1();
while (aux!=NULL) {
VerLlevaZonas(aux);
aux=aux->sig;
}
}
/* Terminan las funciones para ver la tabla LlevaZonas */

/* Empieza el menú principal */
void menu(empleado *emp1,dpto *dpto1,zona *zona1,lleva_zonas
*lleva_zonas1) {
char opcion;
do {
do {
puts("Introduce una opción:\n");
puts("A. Introducir un registro en tabla Empleados.");
puts("B. Introducir un registro en tabla Departamentos.");
puts("C. Introducir un registro en tabla Zonas.");
puts("D. Ver tabla Empleados.");
puts("E. Ver tabla Departamentos.");
puts("F. Ver tabla Zonas.");
puts("G. Ver tabla LlevaZonas.");
puts("H. Salir.\n");
opcion=getch();
} while (opcion<'A' && opcion>'H' && opcion<'a' && opcion>'h');
switch (opcion) {
case 'a':case 'A':
NuevoEmp(emp1);
break;
case 'b':case 'B':
NuevoDpto(dpto1);
break;
case 'c':case 'C':
NuevaZona(zona1);
break;
case 'd':case 'D':
VerTablaEmp(emp1);
break;
case 'e':case 'E':
VerTablaDpto(dpto1);
break;
case 'f':case 'F':
VerTablaZonas(zona1);
break;
case 'g':case 'G':
VerTablaLlevaZonas(lleva_zonas1);
break;
}
} while (opcion!='H' && opcion!='h');
}
/********************termina el bd.h***********************/



Muchas gracias por los comentarios.

[Miguel]

Post by eoliTH
Hola, tengo una pequeña práctica para clase (aún sin acabar) pero ya
tengo una parte completa que debería funcionar y no funciona...La cosa
es que compila con el compilador de Borland (el de las herramientas en
línea de comandos que se pueden descargar gratuitamente de
community.borland.com) pero no funciona muy bien que digamos. Da algunos
errores "de memoria", como por ejemplo en la función NuevoEmp() que se
encuentra en el fichero bd.h, más concretamente al introducir el campo
"nombre". Por favor si veis fallos o si tenéis comentarios o consejos,
/*********** Empieza el archivo bdejempl.c *****************/
#include "bd.h"
void menu(empleado *emp1,dpto *dpto1,zona *zona1,lleva_zonas *lleva_zonas1);

digamos

void menu(empleado **, ...);

Post by eoliTH
int main () {
empleado *emp1=NULL;
dpto *dpto1=NULL;
zona *zona1=NULL;
lleva_zonas *lleva_zonas1=NULL;
menu(emp1,dpto1,zona1,lleva_zonas1);

entonces

menu (&emp1, ...

[...]

Post by eoliTH
/**************** Funciones *****************/
void NuevoEmp(empleado **emp1) {
unsigned int code=0;
empleado *aux;
aux=emp1;

aux = *emp1;

[...]

y así con el resto.

En cuanto a las estructuras, asignas un puntero para el nombre (por
ejemplo), pero nunca el espacio. Puede, en lugar de un puntero definir
un array de char y usar fgets() para leer desde el stdin...

Digamos, defines char puesto[20]; en la estructura empleado y haces un
fgets(aux->puesto, 20, stdin);

Saludos.

[Miguel]

Ahora que lo miro mejor... ¿por qué pones código en la cabecera?

Más aún, para qué necesita una cabecera tu programa si no tienes otro
módulo con quien compartirla :)

Saludos.

[npx]

No solo has de reservar memoria para las estructuras sino que ademas debes
reservarla para todo aquello que lo necesite dentro de la estructura, en
este caso:

- nombre y puesto en empleado
- desc y ubic en dpto
- desc en zonas

Un saludo.

[F L]

Post by npx
No solo has de reservar memoria para las estructuras sino que ademas debes
reservarla para todo aquello que lo necesite dentro de la estructura, en
- nombre y puesto en empleado
- desc y ubic en dpto
- desc en zonas

Si haces malloc del sizeof de una struct, no tienes ya reservada memoria
para todos sus miembros?
Si no es así, que sentido tienen los union?

[Hector Galarza]

Mi experiencia es mayor en c++ asi q no estoy seguro de esto.
malloc te separa espacio para un "pointer" a char en esas estructuras
pero no te separa espacio para las cadenas de caracteres. Recuerda q el
struct lo q dice es char* .... asi q te separa espacio para un pointer
no hacia donde el pionter apunta. Recuerda q un pointer no es mas q una
variable q contiene una direccion de memoria como valor. Encuanto a la
union, la union es completamente diferente. Una union separa un solo
espacio de memoria para todas las variables q contiene. Por ejemplo
puedes hacer algo como:
typedef LongBytes union {
char* bytes;
long val;
};

y bytes[0], bytes[1] ... bytes[sizeof(long)-1] representan los
diferentes bytes de val

Post by F L

Post by npx
No solo has de reservar memoria para las estructuras sino que ademas debes
reservarla para todo aquello que lo necesite dentro de la estructura, en
- nombre y puesto en empleado
- desc y ubic en dpto
- desc en zonas

Si haces malloc del sizeof de una struct, no tienes ya reservada memoria
para todos sus miembros?
Si no es así, que sentido tienen los union?

[Miguel]

Post by Hector Galarza
typedef LongBytes union {
char* bytes;
long val;
};
y bytes[0], bytes[1] ... bytes[sizeof(long)-1] representan los
diferentes bytes de val

NO. char byte[4].

Saludos.

[Hector Galarza]

char bytes [sizeof (long)]
:-)

Post by Miguel

Post by Hector Galarza
typedef LongBytes union {
char* bytes;
long val;
};
y bytes[0], bytes[1] ... bytes[sizeof(long)-1] representan los
diferentes bytes de val

NO. char byte[4].
Saludos.

[npx]

Post by F L

Post by npx
No solo has de reservar memoria para las estructuras sino que ademas
debes reservarla para todo aquello que lo necesite dentro de la
- nombre y puesto en empleado
- desc y ubic en dpto
- desc en zonas

Si haces malloc del sizeof de una struct, no tienes ya reservada
memoria para todos sus miembros?
Si no es así, que sentido tienen los union?

Si y no, malloc te reserva memoria para los miembros pero date cuenta que
en este caso el miembro de la estructura es un puntero, es decir, reserva
memoria para el puntero pero no para el contenido al que va a apuntar.

Un saludo.