Necesito ayuda urgente

[kayron8]

Tengo este ejercicio y no se por donde cojerlo, tengo muy poco hecho, espero que me puedan ayudar:

Ejercicio:

STRUCTS:
1. Dados los siguientes registros:
struct departament{
char nom[30];
char capd[20];
int codi;
};

struct empleat{
char nom[30];
struct departament dept;
float sou;
int codi;
};

Escribe les funciones y el programa principal que servirán para introducir valores a cada campo de los registros y mostrar todos los campos.
Hacer un programa que permita hacer un mantenimiento de los datos de una empresa del estilo struct empleat empresa[MAXT]; Las operaciones serán las típicas de: dar de alta un empleado, dar de baja, listar, modificar los datos, consultar per código.

Lo que llevo hecho:

Código (c) [Seleccionar] Expandir


#include <stdio.h>
#include <stdlib.h>

struct departament{
char nom[30];
char capd[20];
int codi;
};

struct empleat{
char nom[30];
struct departament;
float sou;
int codi;
};dept;

Departament omplir();
void mostrar(Departament dep);
int menu();

departament d;
empleat e;

int res=0,num=0,codi=0,codi_mostra,num_baixa=0;

do{
res=menu();

switch(res){
        case 1:
             codi=alta_client(&c);
             break;
        case 2:
             num=valida_codi(codi);
             break;
        case 3:
             codi_mostra=mostra_client(c);
             break;
        case 4:
             num_baixa=baixa_client(&c);
             
             break;
        case 5:
             
             break;
        case 6:
             
             return 0;
             break;      
        }


 }while(res != 6);
 system("PAUSE");
 return 0;
}


Departament omplir(){
       Departament d;
       printf("Introdueix el nom del departament");
       scanf("%d",&d.nom);
       fflush(stdin);
       printf("Introdueix el cap del departament");
       gets(d.capd);
       fflush(stdin);
       printf("Introdueix el codi");
       scanf("%lf",&d.codi);
       fflush(stdin);
       return d;
       }

int menu(){
   int num;
   do{
   printf("1-Donar d'alta\n2-Donar de baixa\n3-Llistar\n4-Modificar dades\n5-Consultar per codi");
   scanf("%d",&num);
   }while(num<0 || num>5);
   return num;
   
   }


Muchas gracias por la ayuda

[aguml]

tengo dudas con alguna que otra cosa que estáen catalan o no se que es pero intentaré ayudarte. Tengo varias preguntas para poder ayudarte. ¿Puedes usar archivos para guardar los datos o tiene que ser un array de estructuras de tamaño fijo o tiene que ser con asignacion de memoria dinamica? Dependiendo de lo que se use la cosa cambia. En el caso de usar archivos pues necesitarias tocar el tema de archivos de acceso aleatorio, para el caso de usar asignacion de memoria dinamica pues tendrias que estudiar mas el tema de punteros y el uso de malloc y free, y en el caso de usar un tamaño fijo de array de estructura pues la cosa se hace mucho mas sencilla y solo tendrias que tener claro el uso de punteros.

[aguml]

Bueno, no seria tan urgente cuando ni me contestaste 
De todos modos te pongo el enlace a algo que acabo de contestar donde puedes ver un codigo que te puede servir, y mucho, de apoyo para tu tarea: http://foro.elhacker.net/programacion_cc/problema_fwrite-t391462.0.html

[kayron8]

Primero de todo pedir disculpas por mi ausencia, no quisiera dar a entender que he perdido interés y mucho menos abandonar el tema, simplemente he estado en una semana de exámenes y como buen estudiante me puse a hincar los codos jajaja

En su día sí que me urgía que me hacheáis un cable para poder ayudarme a resolver el problema, básicamente el problema que tengo con ese ejercicio es que al no usar un typedef en las estructuras no sé si como lo tengo planteado iba bien y menos aún el uso de registros dentro de otros (en clase no hicimos ningún ejercicio de esas características).

Como aclaración decirte que el ejercicio, según al tema que pertenecía no se debía de  resolver mediante la utilización de ficheros, por lo que lo suyo sería mediante el uso de vectores.

En cuanto al idioma, tal como habrás de deducido, soy catalán, sí que es verdad que parte del ejercicio lo traduje pero de la otra parte no me di cuenta, pido perdón por el despiste.

Con mucho gusto veré el link que me pasaste para que me sirva de ayuda, muchas gracias por tu tiempo y ganas.

¡Un saludo!

[aguml]

con array de estructuras es mas sencillo y claro que puedes anidar structs dentro de structs sin problemas. Ojalá te sirva de ayuda.

[aguml]

Te pongo el codigo modificado para que lo puedas ver con el uso de arrays de structuras:

Código (cpp) [Seleccionar] Expandir

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define SIZEMAX 10 //Indicamos el numero maximo de registros

struct stRegistro {
        int ID;
        char nombre[25];
        int cantidad;
};

int Menu(void);
void ChangeStock(char *operacion, struct stRegistro *reg);
void MostrarCabecera(void);
void MostrarProducto(long n, struct stRegistro *reg);
long LeeNumero(void);
int Borrar(struct stRegistro *reg, long numero);
int Confirmar(char *operacion);
int CountReg(struct stRegistro *reg);
//--------------------------------------------------------------------------

int main()
{
        struct stRegistro reg[SIZEMAX];
        struct stRegistro aux;
        char nombre[25];
        int i, opcion, nRegistros, encontrado, ID, retval;
        long numero;

        memset(reg, 0, sizeof(reg));
        do {
                opcion = Menu();
                switch(opcion) {
                        case '1': // Añadir o incrementar el stock
                                encontrado = 0;
                                nRegistros = CountReg(reg);
                                ChangeStock("Añadir al stock", &aux);
                                for(i = 0; i<nRegistros; i++)
                                {
                                        if(strcmp(aux.nombre, reg[i].nombre) == 0 &&
                                           Confirmar("incremenar la existencia del producto indicado") == 1)
                                        {
                                                reg[i].cantidad += aux.cantidad;
                                                encontrado = 1;
                                                printf("\nSe a incrementado satisfactoriamente el stockaje del producto.\n\n");
                                                break;
                                        }
                                }
                                if(encontrado == 0 && Confirmar("incorporar un nuevo producto al stock") == 1)
                                {
                                        if(nRegistros == 0)
                                                ID = 1;
                                        else
                                        {
                                                ID = reg[i-1].ID + 1;
                                        }
                                        reg[i].ID = ID;
                                        strcpy(reg[i].nombre, aux.nombre);
                                        reg[i].cantidad = aux.cantidad;
                                        printf("\nSe ha añadido satisfactoriamente una nueva entrada al stockage.\n\n");
                                }
                                system("PAUSE");
                                break;
                        case '2': // Ventas de stockaje
                                encontrado = 0;
                                nRegistros = CountReg(reg);
                                ChangeStock("Venta de stockaje", &aux);
                                for(i = 0; i < nRegistros; i++)
                                {
                                        if(strcmp(aux.nombre, reg[i].nombre) == 0)
                                        {
                                                encontrado = 1;
                                                if(aux.cantidad <= reg[i].cantidad)
                                                {
                                                        reg[i].cantidad -= aux.cantidad;
                                                        printf("\nLa venta se ha realizado satisfactoriamente.\n\n");
                                                }else{
                                                        printf("\nNo hay suficiente stockaje de ese producto para esta venta.\n");
                                                        MostrarCabecera();
                                                        MostrarProducto(i, &reg[i]);
                                                        printf("|---------|-------------------------|--------|\n\n");
                                                }
                                                break;
                                        }
                                }
                                if(encontrado == 0)
                                {
                                        printf("\nNo se puede encontrar el producto indicado.\n\n");
                                }
                                system("PAUSE");
                                break;
                        case '3': // Mostrar stock de un producto por su ID
                                encontrado = 0;
                                system("cls");
                                printf("Buscar stock por ID: ");
                                ID = LeeNumero();
                                nRegistros = CountReg(reg);
                                for(i = 0; i < nRegistros; i++)
                                {
                                        if(ID == reg[i].ID)
                                        {
                                                encontrado = 1;
                                                MostrarCabecera();
                                                MostrarProducto(i, &reg[i]);
                                                break;
                                        }
                                }
                                if(encontrado == 0)
                                {
                                        printf("\nNo se puede encontrar el producto indicado.\n\n");
                                }
                                else
                                {
                                        printf("|---------|-------------------------|--------|\n\n");
                                }
                                system("PAUSE");
                                break;
                        case '4': // Mostrar stock de un producto por su nombre
                                encontrado = 0;
                                system("cls");
                                printf("Buscar stock por nombre: ");
                                fgets(nombre, 25, stdin);
                                for(i = strlen(nombre) - 1; i && nombre[i] < ' '; i--)
                                        nombre[i] = 0;
                                nRegistros = CountReg(reg);
                                for(i = 0; i < nRegistros; i++)
                                {
                                        if(strcmp(nombre, reg[i].nombre) == 0)
                                        {
                                                encontrado = 1;
                                                MostrarCabecera();
                                                MostrarProducto(i, &reg[i]);
                                                break;
                                        }
                                }
                                if(encontrado == 0)
                                {
                                        printf("\nNo se puede encontrar el producto indicado.\n\n");
                                        system("PAUSE");
                                }
                                else
                                {
                                        printf("|---------|-------------------------|--------|\n\n");
                                }
                                system("PAUSE");
                                break;
                        case '5': // Mostrar todo el stockaje
                                encontrado = 0;
                                numero = 0;
                                system("cls");
                                nRegistros = CountReg(reg);
                                if(nRegistros > 0)
                                {
                                        encontrado = 1;
                                        MostrarCabecera();
                                        for(i = 0; i < nRegistros; i++)
                                        {
                                                MostrarProducto(numero++, &reg[i]);
                                        }
                                        printf("|---------|-------------------------|--------|\n\n");
                                }
                                if(encontrado == 0)
                                {
                                        printf("\nNo existen entradas en el registro.\n");
                                }
                                system("PAUSE");
                                break;
                        case '6': // Eliminar del stock
                                system("cls");
                                printf("Eliminar del stock: ");
                                numero = LeeNumero();
                                retval = Borrar(reg, numero);
                                if(retval == 0)
                                {
                                        printf("\nNo existe ese ID de producto.\n\n");
                                }
                                else if(retval == 1)
                                {
                                        printf("\nEntrada borrada satisfactoriamente.\n\n");
                                }
                                else if(retval == -1)
                                {
                                        printf("\nNo se ha realizado ningun cambio.\n\n");
                                }
                                system("PAUSE");
                                break;
                }
        } while(opcion != '0');
        return 0;
}
//--------------------------------------------------------------------------

// Muestra un menú con las opciones disponibles y captura una opción del usuario
int Menu(void)
{
        char resp[20];
        do {
                system("cls");
                printf("MENU PRINCIPAL\n");
                printf("--------------\n\n");
                printf("1- Añadir al stock\n");
                printf("2- Venta\n");
                printf("3- Buscar stock por su ID\n");
                printf("4- Buscar stock por su nombre\n");
                printf("5- Mostrar todo el stockaje\n");
                printf("6- Eliminar producto del stock por su ID\n");
                printf("0- Salir\n");
                fgets(resp, 20, stdin);
        } while(resp[0] < '0' && resp[0] > '6');
        return resp[0];
}
//--------------------------------------------------------------------------

// Permite que el usuario introduzca un producto por pantalla
void ChangeStock(char *operacion, struct stRegistro *reg)
{
        int i;
        char numero[6];
        system("cls");
        printf("%s:", operacion);
        printf("\n\n");
        printf("Nombre: ");
        fgets(reg->nombre, 25, stdin);
        // la función fgets captura el retorno de línea, hay que eliminarlo:
        for(i = strlen(reg->nombre) - 1; i && reg->nombre[i] < ' '; i--)
                reg->nombre[i] = 0;
        printf("Cantidad: ");
        fgets(numero, 6, stdin);
        reg->cantidad = atoi(numero);
}
//--------------------------------------------------------------------------

// Muestra la cabecera de la tabla por pantalla
void MostrarCabecera(void)
{
        printf("\n");
        printf("|---------|-------------------------|--------|\n"
               "|ID       |Nombre                   |Cantidad|\n"
               "|---------|-------------------------|--------|\n");
}
//--------------------------------------------------------------------------

// Muestra un producto por pantalla
void MostrarProducto(long n, struct stRegistro *reg)
{
        printf("|[%6ld] |%-25s| %4d   |\n", reg->ID, reg->nombre, reg->cantidad);
}
//--------------------------------------------------------------------------

// Lee un número suministrado por el usuario
long LeeNumero()
{
        char numero[6];
        fgets(numero, 6, stdin);
        return atoi(numero);
}
//--------------------------------------------------------------------------

// Borra una entrada del archivo
int Borrar(struct stRegistro *reg, long numero)
{
        struct stRegistro temp[SIZEMAX];
        int nRegistros, i, j, encontrado = 0;

        nRegistros = CountReg(reg);
        for(i = 0, j = 0; i < nRegistros; i++)
        {
                if(numero != reg[i].ID)
                {
                        temp[j].ID = reg[i].ID;
                        strcpy(temp[j].nombre,reg[i].nombre);
                        temp[j].cantidad = reg[i].cantidad;
                        j++;
                }
                else
                {
                        encontrado = 1;
                }
        }
        if(encontrado == 1)
        {
                if(Confirmar("eliminar la entrada indicada"))
                {
                        memset(reg, 0, sizeof(struct stRegistro) * nRegistros);
                        for(i = 0; i < nRegistros - 1; i++)
                        {
                                reg[i].ID = temp[i].ID;
                                strcpy(reg[i].nombre, temp[i].nombre);
                                reg[i].cantidad = temp[i].cantidad;
                        }
                }
                else
                {
                        encontrado = -1;
                }
        }
        return encontrado;
}
//--------------------------------------------------------------------------

int Confirmar(char *operacion)
{
        char valor;
        int salida = 0;

        printf("Esta apunto de %s. Pulse 'S' y pulse intro para confirmar: ", operacion);
        valor = getchar();
        if(valor == 's' || valor == 'S')
        {
                salida = 1;
        }
        return salida;
}
//--------------------------------------------------------------------------

int CountReg(struct stRegistro *reg)
{
        int i;

        for(i = 0; i < SIZEMAX; i++)
                if(strcmp(reg[i].nombre, "")==0)
                        break;
        return i;
}
//--------------------------------------------------------------------------

[kayron8]

Muchas gracias por tu ayuda aguml

¡Un saludo!