Foro de elhacker.net

este es el main.c ::) ::)

#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
#include <conio.h>
#include "lib.h"
 
#define Amoladora 0
#define Mezcladora 1
#define Taladro 2
 
   int main()
{
    eTipoEquipo equipos[3];
    eCliente clientes[100];
    eAlquiler alquiler[100];
    eAlquiler alquileres[100];
    eTipoEquipo tipos;
    int tam;
    int idCliente=10;
    int idAlquiler=20;
    int altaC;
    int i;
    int id;
    int altaA;
    int cont[i];
    inicializarClientes(clientes, 100);
 
    char seguir='s';
    int opcion;
    int confirma;
 
    do
    {
        printf("\n                             ::MENU DE OPCIONES::\n\n");
        printf("1. Alta de cliente\n");
        printf("2. Modificar datos del cliente\n");
        printf("3. Baja del cliente\n");
        printf("4. Nuevo alquiler\n");
        printf("5. Fin del alquiler\n");
        printf("6. Informar\n");
        printf("7. Salir\n\n");
 
        printf("* Elija una opcion: ");
        scanf("%d", &opcion);
 
        switch(opcion)
        {
        case 1:
            altaC=altaCliente(clientes, idCliente, 100);
            if (altaC!=-1)
            {
                cont[i]=cont[i]++;
                idCliente++;
            }
            break;
        case 2:
            modificarCliente(clientes, idCliente, 100);
            break;
        case 3:
            bajaCliente(clientes, idCliente, 100);
            break;
        case 4:
            altaA=nuevoAlquiler(alquiler, clientes, equipos, 100, idAlquiler);
            if (altaA!=-1)
            {
                idAlquiler++;
            }
            break;
        case 5:
            finAlquiler(alquiler, 100);
            break;
        case 6:
            clienteRecurrente(alquileres,clientes , tam, id);
            mayorAlquiler(alquileres,tipos , tam);
            informar (alquileres,clientes,tipos,tam);
            break;
        case 7:
            printf("Usted eligio salir. Confirma salir? s/n\n");
            confirma=tolower(getch());
            if (confirma=='s')
            {
                seguir='n';
            }
            else
            {
                break;
            }
            break;
        }system("cls");
    }while(seguir=='s');
return 0;
}
 
 
 
ESTE ES EL LIB.H ::) ::)
 
 
#define LIB.H
typedef struct
{
    int id;
    int dni;
    char nombre[20];
    char apellido[20];
    int estado;
}eCliente;
 
typedef struct
{
    int idTipo;
    char descripcion[10];
}eTipoEquipo;
 
typedef struct
{
    int id;
    int cliente;
    int estado;
    int equipo;
    int tiempoEsti;
    int tiempoReal;
}eAlquiler;
 
/** \brief Inicializa los clientes con estado en 0
 *
 * \param Array de clientes
 * \param Tamaño del array
 *
 */
void inicializarClientes (eCliente[], int);
 
/** \brief Busca el primer espacio libre en el array de clientes
 *
 * \param Array de clientes
 * \param Tamaño del array
 * \return El indice del primer espacio libre
 *
 */
int buscarLibre (eCliente[], int);
 
/** \brief Da de alta un cliente
 *
 * \param Array de clientes
 * \param Id del cliente
 * \param Tamaño del array
 * \return El cliente
 *
 */
int altaCliente (eCliente[], int, int);
 
/** \brief Modifica algunos datos seleccionados del cliente
 *
 * \param Array de clientes
 * \param Id del cliente
 * \param Tamaño del array
 *
 */
void modificarCliente (eCliente[], int, int);
 
/** \brief Muestra los clientes habilitados en sistema
 *
 * \param Array de clientes
 * \param Tamaño del array
 *
 */
void mostrarClientes (eCliente[], int);
 
/** \brief Realiza la baja lógica de un cliente en sistema. (estado=2)
 *
 * \param Array de clientes
 * \param ID del cliente
 * \param Tamaño del array
 *
 */
void bajaCliente (eCliente[], int, int);
 
/** \brief Muestra los tipos de equipos
 *
 * \param Array de tipos
 * \param Tamaño del array
 *
 */
void mostrarTipos(eTipoEquipo[], int);
 
/** \brief Habilita en sistema un nuevo alquiler
 *
 * \param Array de alquileres
 * \param Array de clientes
 * \param Array de tipos de equipos
 * \param Tamaño del array
 * \param ID del alquiler
 * \return El indice del alquiler
 *
 */
int nuevoAlquiler (eAlquiler[], eCliente[], eTipoEquipo[], int, int);
 
/** \brief Realiza el fin de un alquiler
 *
 * \param Array de alquileres
 * \param Tamaño del array
 *
 */
void finAlquiler (eAlquiler[], int);
 
/** \brief Busca un alquiler por su ID
 *
 * \param Array de alquileres
 * \param Tamaño del array
 * \param ID del alquiler
 * \return El indice del alquiler
 *
 */
int buscarAlquiler (eAlquiler[], int, int);
 
/** \brief Informa segun varios criterios
 *
 * \param Array de clientes
 * \param Tamaño del array
 *
 */
int clienteRecurrente(eAlquiler[], eCliente[], int, int);
int mayorAlquiler(eAlquiler[], eTipoEquipo, int);
void informar (eAlquiler[], eCliente[],eTipoEquipo, int);
 
 
 
ESTE ES EL LIB.C ::) ::)
 
 
 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include <conio.h>
#include "lib.h"
 
void inicializarClientes (eCliente clientes[], int tam)
{
    int i;
    for (i=0;i<tam;i++)
    {
        clientes[i].estado=0;
    }
}
 
void inicializarTipos(eTipoEquipo tipo[], int tam)
{
        tipo[0].idTipo = 0;
        strcpy(tipo[0].descripcion, "Amoladora");
 
        tipo[1].idTipo = 1;
        strcpy(tipo[1].descripcion, "Mezcladora");
 
        tipo[2].idTipo = 2;
        strcpy(tipo[2].descripcion, "Taladro");
}
 
int buscarLibre (eCliente clientes[], int tam)
{
    int indice=-1;
    int i;
    for (i=0;i<tam;i++)
    {
        if(clientes[i].estado == 0)
        {
            indice=i;
            break;
        }
    }
    return indice;
}
 
int buscarCliente (eCliente clientes[], int tam, int id)
{
    int indice=-1;
    int i;
    for (i=0;i<tam;i++)
    {
        if (clientes[i].id == id)
        {
            indice=i;
            break;
        }
    }
    return indice;
}
 
int altaCliente (eCliente clientes[], int id, int tam)
{
    int indice;
    int i;
    int cont[i];
    char auxCad[40];
    indice=buscarLibre(clientes, tam);
    cont[i]=0;
    if (indice==-1)
    {
        printf("No hay mas espacio de carga de clientes. Verifique.\n");
    }
    else
    {
        cont[i]=cont[i]+1;
        clientes[indice].id=id;
        printf("\nID: %d\n", clientes[indice].id);
 
        printf("Ingrese el DNI: ");
        fflush(stdin);
        scanf("%d", &clientes[indice].dni);
        while (clientes[indice].dni < 0)
        {
            printf("El DNI debe ser positivo. Reingrese: ");
            fflush(stdin);
            scanf("%d", &clientes[indice].dni);
        }
 
        printf("Ingrese el nombre: ");
        fflush(stdin);
        gets(auxCad);
        while (strlen(auxCad)>20)
        {
            printf("Nombre demasiado largo. Reingrese: ");
            fflush(stdin);
            gets(auxCad);
        }
        strcpy(clientes[indice].nombre, auxCad);
 
        printf("Ingrese el apellido: ");
        fflush(stdin);
        gets(auxCad);
        while (strlen(auxCad)>20)
        {
            printf("Apellido demasiado largo. Reingrese: ");
            fflush(stdin);
            gets(auxCad);
        }
        strcpy(clientes[indice].apellido, auxCad);
 
        clientes[indice].estado=1;
        printf("Cliente cargado exitosamente.\n");
    }
    system("pause");
    return indice;
}
 
void mostrarClientes (eCliente clientes[], int tam)
{
    int i;
 
    printf("\n                  ::Clientes habilitados::\n\n");
    for (i=0;i<tam;i++)
    {
        if (clientes[i].estado == 1)
        {
            printf("\nID: %d\n", clientes[i].id);
            printf("DNI: %d\n", clientes[i].dni);
            printf("Nombre: %s\n", clientes[i].nombre);
            printf("Apellido: %s\n", clientes[i].apellido);
        }
    }
}
 
void modificarCliente (eCliente clientes[], int id, int tam)
{
    int indice;
    int opcion;
    char auxCad[40];
 
    mostrarClientes(clientes, tam);
 
    printf("\nIngrese el ID del cliente a modificar: ");
    fflush(stdin);
    scanf("%d", &id);
 
    indice=buscarCliente(clientes, tam, id);
    if (indice==-1)
    {
        printf("El cliente no esta en el sistema. Verifique el ID.\n");
        system("pause");
    }
    else
    {
        printf("\n                            ::MENU DE MODIFICACION::\n\n");
 
        printf("1. Nombre\n");
        printf("2. Apellido\n\n");
 
        printf("Escoja una opcion: ");
        fflush(stdin);
        scanf("%d", &opcion);
 
        switch (opcion)
        {
        case 1:
            printf("Ingrese el nuevo nombre: ");
            fflush(stdin);
            gets(auxCad);
            while (strlen(auxCad)>20)
            {
            printf("Nombre demasiado largo. Reingrese: ");
            fflush(stdin);
            gets(auxCad);
            }
            strcpy(clientes[indice].nombre, auxCad);
            printf("Nombre modificado con exito.\n");
            system("pause");
            break;
        case 2:
            printf("Ingrese el nuevo apellido: ");
            fflush(stdin);
            gets(auxCad);
            while (strlen(auxCad)>20)
            {
            printf("Apellido demasiado largo. Reingrese: ");
            fflush(stdin);
            gets(auxCad);
            }
            strcpy(clientes[indice].apellido, auxCad);
            printf("Apellido modificado con exito.\n");
            system("pause");
            break;
        }
    }
}
 
void bajaCliente (eCliente clientes[], int id, int tam)
{
    int indice;
    int confirma;
 
    mostrarClientes(clientes, tam);
 
    printf("\nIngrese ID del cliente que desea dar de baja: ");
    scanf("%d", &id);
 
    indice=buscarCliente(clientes, tam, id);
 
    if (indice == -1)
    {
        printf("Este cliente no puede ser dado de baja porque no existe en el sistema.\n");
        system("pause");
    }
    else
    {
        printf("Usted va a dar de baja a este cliente. Esta seguro de la baja? s/n\n");
        confirma=tolower(getch());
 
        if (confirma == 's')
        {
            clientes[indice].estado=2;
            printf("Cliente dado de baja exitosamente.\n");
            system("pause");
        }
        else
        {
            printf("La baja ha sido cancelada.\n");
            system("pause");
        }
    }
}
 
int buscarLibreAlquiler (eAlquiler alquileres[], int tam)
{
    int indice=-1;
    int i;
    for (i=0;i<tam;i++)
    {
        if(alquileres[i].estado == 0)
        {
            indice=i;
            break;
        }
    }
    return indice;
}
 
int menuTipo(eTipoEquipo tipos[], int tam)
{
    int tipo;
    mostrarTipos(tipos, tam);
    printf("Elija un tipo: ");
    fflush(stdin);
    scanf("%d", &tipo);
 
    return tipo;
}
 
void mostrarTipos(eTipoEquipo tipos[], int tam)
{
    printf("\n         :: TIPOS DE EQUIPO ::\n\n");
 
    printf("0. Amoladora\n");
    printf("1. Mezcladora\n");
    printf("2. Taladro\n\n");
}
 
int nuevoAlquiler (eAlquiler alquileres[], eCliente clientes[], eTipoEquipo equipos[], int tam, int id)
{
    int indice;
    int aux;
    indice=buscarLibreAlquiler(alquileres, tam);
    if (indice==-1)
    {
        printf("\nNo hay mas espacio para cargar alquileres.\n");
    }
    else
    {
        alquileres[indice].id=id;
        printf("\nID de alquiler: %d\n", alquileres[indice].id);
        mostrarClientes(clientes, tam);
        printf("\nID del cliente: ");
        fflush(stdin);
        scanf("%d", &alquileres[indice].cliente);
        alquileres[indice].equipo=menuTipo(equipos, tam);
        alquileres[indice].estado=1;
        printf("\nElija un tiempo estimado: ");
        fflush(stdin);
        scanf("%d", &aux);
        while (aux < 0)
        {
            printf("El tiempo no puede ser negativo. Reingrese: ");
            fflush(stdin);
            scanf("%d", &aux);
        }
        alquileres[indice].tiempoEsti=aux;
        printf("\n\nAlquiler ingresado en sistema exitosamente. Volvera al menu principal.\n");
        system("pause");
    }
    return indice;
}
 
void mostrarAlquileres (eAlquiler alquileres[], int tam)
{
    char tipos[][15]={"Amoladora", "Mezcladora", "Taladro"};
    int i;
    int tipo;
    int cont0;
    int cont1;
    int cont2;
    printf("\n                             ::ALQUILERES EN CURSO::\n");
 
    for (i=0;i<tam;i++)
    {
        if (alquileres[i].estado==1)
        {
            if (alquileres[i].id >= 20 && alquileres[i].id <= 100)
            {
            printf("\n\nID del alquiler: %d\n", alquileres[i].id);
            printf("ID del cliente: %d\n", alquileres[i].cliente);
            printf("Tipo: %s\n", tipos[alquileres[i].equipo]);
            printf("Tiempo estimado: %d\n", alquileres[i].tiempoEsti);
        if(tipo==0)
    {
        cont0=cont0+1;
    }
    if(tipo==1)
    {
        cont1=cont1+1;
    }
    if(tipo==2)
    {
        cont2=cont2+1;
    }
            }
        }
    }
}
 
int buscarAlquiler (eAlquiler alquileres[], int tam, int id)
{
    int indice=-1;
    int i;
    for (i=0;i<tam;i++)
    {
        if (alquileres[i].id == id)
    {
        indice=i;
    }
    }
    return indice;
}
 
void finAlquiler (eAlquiler alquileres[], int tam)
{
    int indice;
    int id;
    int confirma;
 
    mostrarAlquileres(alquileres, tam);
 
    printf("\nIngrese el ID del alquiler a finalizar: ");
    fflush(stdin);
    scanf("%d", &id);
 
    indice=buscarAlquiler(alquileres, tam, id);
    if (indice==-1)
    {
        printf("El alquiler no fue encontrado. Verifique el ID.\n");
        system("pause");
    }
    else
    {
        printf("Esta seguro que desea dar de baja este alquiler? s/n\n");
        confirma=tolower(getch());
        if (confirma == 's')
        {
            alquileres[indice].estado=2;
            printf("Ingrese el tiempo real de este alquiler: ");
            fflush(stdin);
            scanf("%d", &alquileres[indice].tiempoReal);
            printf("Alquiler finalizado.\n");
            system("pause");
        }
        else
        {
            printf("Baja del alquiler cancelada.\n");
            system("pause");
        }
    }
}
int clienteRecurrente(eAlquiler alquileres[], eCliente clientes[], int tam, int id)
{
    int indice;
    int i;
    mostrarAlquileres(alquileres, tam);
    indice=buscarAlquiler(alquileres, tam, id);
}
 
int mayorAlquiler(eAlquiler alquileres[],eTipoEquipo tipos,int tam)
{
    int indice;
    int id;
    int i;
    mostrarAlquileres(alquileres, tam);
    indice=buscarAlquiler(alquileres, tam, id);
    int cont0;
    int cont1;
    int cont2;
    int mayorAlq;
     for (i=0;i<tam;i++)
    {
    if (indice==1)
    {
    if(cont0>cont1 && cont0>cont2)
    {
        mayorAlq=cont0;
    }
     if(cont1>cont0 && cont1>cont2)
    {
        mayorAlq=cont1;
    }
     if(cont2>cont0 && cont2>cont1)
    {
        mayorAlq=cont2;
    }
        if(mayorAlq==cont0)
    {
        printf("el equipo mas alquilado fue la amoladora, y se alquilo %d veces\n",cont0);
    }
    if(mayorAlq==cont1)
    {
        printf("el equipo mas alquilado fue la mezcladora, y se alquilo %d veces\n",cont1);
    }
    if(mayorAlq==cont2)
    {
        printf("el equipo mas alquilado fue el taladro, y se alquilo %d veces\n",cont2);
    }
    }
    }
}
void informar (eAlquiler alquileres[], eCliente clientes[], eTipoEquipo tipos,int tam)
{
    int opcion;
    printf("\n                             ::INFORMAR::\n\n");
    printf("1. Asociado con mas alquileres\n");
    printf("2. Los equipos mas alquilados\n");
    printf("3. Tiempo promedio real de alquiler\n");
 
    printf("\n* Elija una opcion: ");
    fflush(stdin);
    scanf("%d", &opcion);
 
    switch(opcion)
    {
        case 1:
            break;
        case 2:
            mayorAlquiler(alquileres,tipos,tam);
            break;
        case 3:
            mostrarAlquileres(alquileres, tam);
            break;
    }
}

ya se habran dado cuenta lo que tengo que hacer, dar alta a un cliente, poder modificarlo y borrarlo, y hacer que alquile, eso me sale.
pero el profesor me pidio que haga un informar para que este informe 3 cosas
-la persona de id con mas alquileres.
-el equipo mas alquilado.
-mostrar el tiempo estimado, por favor ayudaaa ya nose que hacer






Mod: Los códigos deben ir en etiquetas GeSHi, no se debe escribir en mayúsculas

intentaste usar el debugger de tu ide y correr el programa?

si y no me hace nada, necesito que alguien me ayude porfa, tengo que entregar este parcial ahora

no se que trataste de decir... el debugger algo debe hacer, si te lanza error de exit estatus normalmente es que intentaste acceder a un punto de memoria ilegal...

tu programa es relativamente largo y hay que seguir cosas, aqui no se te va a dar hecho se te va a explicar como resolver el problema...

dime lo que intentaste con el debugger y que es lo "que no hace nada"

Como te dice Engel lex, di donde tienes el problema, si no es un poco complicado... lleva rato analizar código ya escrito.

Como dato, en un par de funciones te falta retornar la función.

int clienteRecurrente(eAlquiler alquileres[], eCliente clientes[], int tam, int id);
int mayorAlquiler(eAlquiler alquileres[],eTipoEquipo tipos,int tam);

saludos.