I have some problems with linked lists - c

I have some problems with my code. I want to load a file (i can do it in "cargar" function), i have my menu, my "show list" function (mostrar_lista) and my "add function" (anadir_elemento) but i have problems with guardar (my save function).
When I use my save function (guardar) i can't save anything, my file "records.txt" just collapses and i have a file with 700.000 Kbytes.
The code:
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
struct unDisco{
char titulo[100];
char artista[100];
short fecha;
char formato[50];
float precio;
struct unDisco *siguiente;
};
struct unDisco *primero, *ultimo;
void cargar(){
FILE *discoteca;
discoteca = fopen("records.txt","r");
if (discoteca==NULL){
return ;
}else{
char ayuda, titulo[100], artista[100], formato[50];
int cont=0, k, fecha, n;
float precio;
while((ayuda=fgetc(discoteca))!=EOF){
if (ayuda=='\n'){
cont++;
}
}
rewind(discoteca);
char linea[cont][1024];
for (k=0;k<cont;k++){
fgets(linea[k],1023,discoteca);
struct unDisco *disco=(struct unDisco *)malloc(sizeof(struct unDisco));
sscanf(linea[k]," %s %s %i %s %f", titulo,artista,&fecha,formato,&precio);
strcpy(disco->titulo, titulo);
strcpy(disco->artista, artista);
strcpy(disco->formato, formato);
disco->fecha=fecha;
disco->precio=precio;
if (primero==NULL) {
primero = disco;
ultimo = disco;
}
else {
ultimo->siguiente = disco;
ultimo = disco;
}
}
}
fclose(discoteca);
return ;
}
void mostrar_menu() {
printf("\n\nMenú:\n=====\n\n");
printf("1.- Añadir elementos\n");
printf("2.- Borrar elementos\n");
printf("3.- Mostrar lista\n");
printf("4.- Salir\n\n");
printf("Escoge una opción: ");fflush(stdout);
}
void anadir_elemento() {
struct unDisco *disco;
int data;
float prezo;
char titulo[100],artista[100],formato[50];
//reservamos memoria para el nuevo elemento
disco = (struct unDisco *) malloc (sizeof(struct unDisco));
printf("\nTitulo: "); fflush(stdout);
fscanf(stdin," %s",titulo);
printf("Artista: "); fflush(stdout);
fscanf(stdin," %s",artista);
printf("Fecha: "); fflush(stdout);
fscanf(stdin," %i",&data);
printf("Formato: "); fflush(stdout);
fscanf(stdin," %s",formato);
printf("Precio: "); fflush(stdout);
fscanf(stdin," %f",&prezo);
strcpy(disco->titulo, titulo);
strcpy(disco->artista, artista);
strcpy(disco->formato, formato);
disco->fecha=data;
disco->precio=prezo;
// el campo siguiente va a ser NULL por ser el último elemento de la lista
disco->siguiente = NULL;
// ahora metemos el nuevo elemento en la lista. lo situamos al final de la lista
//comprobamos si la lista está vacía. si primero==NULL es que no hay ningún elemento en la lista. también vale ultimo==NULL
if (primero==NULL) {
printf( "Primer elemento\n");
primero = disco;
ultimo = disco;
}
else {
// el que hasta ahora era el último tiene que apuntar al nuevo
ultimo->siguiente = disco;
// hacemos que el nuevo sea ahora el último
ultimo = disco;
}
}
void mostrar_lista() {
struct unDisco *auxiliar; // lo usamos para recorrer la lista
int i;
i=0;
auxiliar = primero;
printf("\nMostrando la lista completa:\n");
while (auxiliar!=NULL) {
printf( "Titulo: %s, Artista: %s, Fecha: %i, Formato: %s, Precio: %.2f",
auxiliar->titulo,auxiliar->artista,auxiliar->fecha,auxiliar->formato,auxiliar->precio);
auxiliar = auxiliar->siguiente;
i++;
}
if (i==0) printf( "\nLa lista está vacía!!\n" );
}
void guardar(){
FILE *discoteca;
struct unDisco *disco;
discoteca=fopen("records.txt","w");
while(disco->siguiente!=NULL){
fprintf(discoteca,"%s %s %i %s %.2f\n",
disco->titulo, disco->artista, disco->fecha, disco->formato, disco->precio);
}
fclose(discoteca);
}
int main(){
char opcion;
cargar();
primero = (struct unDisco *) NULL;
ultimo = (struct unDisco *) NULL;
do {
mostrar_menu();
fscanf(stdin," %c",&opcion);
switch ( opcion ) {
case '1': anadir_elemento();
break;
case '2': printf("No disponible todavía!\n");
break;
case '3': mostrar_lista(primero);
break;
case '4':
guardar();
exit( 1 );
break;
default: printf( "Opción no válida\n" );
break;
}
} while (opcion!='4');
return 0;
}

it seems logical that guardar receives the unDisco in parameter, something like
void guardar(struct unDisco *disco){
FILE *discoteca = fopen("records.txt","w");
while(disco != NULL) { /* <<< test changed */
fprintf(discoteca,"%s %s %i %s %.2f\n",
disco->titulo, disco->artista,
disco->fecha, disco->formato,
disco->precio);
disco = disco->siguiente; /* <<< added */
}
fclose(discoteca);
}

Related

Error "a label can only be part of a statement" when compiling file line 17 in the main() function [duplicate]

This question already has answers here:
Why can we not declare a variable after a switch case colon without using curly braces?
(3 answers)
Closed last month.
I have a problem compiling the code in the main file at line 17.
The error is
"a label can only be part of a statement and a declaration is not a statement".
#ifndef HEADER_H_INCLUDED
#define HEADER_H_INCLUDED
#define TAILLE_MAX_NOM 50
// Définition du type Compte
typedef struct {
int RIB;
float solde;
char etat[TAILLE_MAX_NOM];
float plafond_credit;
int nb_operations;
float operations[100];
} Compte;
Compte T_Compte[100];
int menu();
void CreerCompte(Compte *C);
int ChercherCompte(Compte T_Compte[],int NC,int RIB );
void AjouterCompte (Compte T_Compte[], int *NC, Compte C);
float Ajouter_Retirer (Compte T_Compte[], int NC, float M,int RIB);
void ListeComptes(Compte T_Compte[], int NC);
void StatCompte (Compte T_Compte[], int NC, int *PNBA,int *PNBR ,int RIB);
void Prime (Compte T_Compte[], int NC);
#endif // HEADER_H_INCLUDED
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "header.h"
int menu() {
int choix;
printf("\n\n -> Menu <- \n\n");
printf(" 1 - Ajouter un Nouveau Compte \n");
printf(" 2 - Afficher les comptes de la banque \n");
printf(" 3 - Ajouter une operation a un compte\n");
printf(" 4 - Attribuer une prime aux meilleurs comptes bancaires \n");
printf(" 0 - Quitte\n");
printf("\n --------------------------------------\n");
do {
printf(" -> Tapez votre choix : ");
scanf("%d",&choix);
printf("\n\n");
} while (choix>4 || choix<0);
return choix;
}
void CreerCompte(Compte *C) {
printf("RIB du compte : ");
scanf("%d", &C->RIB);
printf("Solde initial du compte (supérieur ou égal à 50) : ");
scanf("%f", &C->solde);
while (C->solde < 50) {
printf("Le solde initial doit être supérieur ou égal à 50 !\n");
printf("Solde initial du compte (supérieur ou égal à 50) : ");
scanf("%f", &C->solde);
}
strcpy(C->etat, "debiteur");
printf("Plafond de crédit du compte (strictement négatif supérieur à -500) : ");
scanf("%f", &C->plafond_credit);
while (C->plafond_credit >= 0 || C->plafond_credit <= -500) {
printf("Le plafond de crédit doit être un montant strictement négatif supérieur à -500 !\n");
printf("Plafond de crédit du compte (strictement négatif supérieur à -500) : ");
scanf("%f", &C->plafond_credit);
}
C->nb_operations = 0;
}
int ChercherCompte(Compte T_Compte[], int NC, int RIB) {
for (int i = 0; i < NC; i++) {
if (T_Compte[i].RIB == RIB) {
return i;
}
}
return -1;
}
void AjouterCompte(Compte T_Compte[], int *NC, Compte C) {
if (ChercherCompte(T_Compte, *NC, C.RIB) != -1) {
printf("Un compte avec ce RIB existe déjà !\n");
return;
}
T_Compte[*NC] = C;
(*NC)++;
}
float Ajouter_Retirer(Compte T_Compte[], int NC, float M, int RIB) {
// Vérifie que la somme à ajouter ou retirer est non nulle
if (M == 0) {
printf("La somme à ajouter ou retirer ne peut pas être nulle !\n");
return -1;
}
// Cherche le compte dans le tableau
int pos = ChercherCompte(T_Compte, NC, RIB);
// Vérifie que le compte existe
if (pos == -1) {
printf("Le compte avec le RIB spécifié n'existe pas !\n");
return -1;
}
Compte C = T_Compte[pos];
// Vérifie que l'opération de retrait peut être effectuée
if (M < 0 && (C.solde + M < -C.plafond_credit)) {
printf("Opération de retrait impossible !\n");
return -1;
}
// Effectue l'opération
C.solde += M;
C.nb_operations++;
T_Compte[pos] = C;
return C.solde;
}
void ListeComptes(Compte T_Compte[], int NC) {
printf("Liste des comptes de la banque :\n");
for (int i = 0; i < NC; i++) {
Compte C = T_Compte[i];
printf("RIB : %d, Solde : %.2f, Etat : %s, Plafond de crédit : %.2f, Nombre d'opérations : %d\n",
C.RIB, C.solde, C.etat, C.plafond_credit, C.nb_operations);
}
}void StatCompte(Compte T_Compte[], int NC, int *PNBA, int *PNBR, int RIB) {
// Initialise les compteurs à 0
*PNBA = 0;
*PNBR = 0;
// Cherche le compte dans le tableau
int pos = ChercherCompte(T_Compte, NC, RIB);
if (pos == -1) {
printf("Le compte avec ce RIB n'existe pas !\n");
return;
}
// Parcours les opérations du compte
Compte C = T_Compte[pos];
for (int i = 0; i < C.nb_operations; i++) {
if (C.operations[i] > 0) {
(*PNBA)++;
} else if (C.operations[i] < 0) {
(*PNBR)++;
}
}
}
void Prime(Compte T_Compte[], int NC) {
printf("Attribution de la prime aux meilleurs comptes de la banque :\n");
for (int i = 0; i < NC; i++) {
Compte C = T_Compte[i];
// Vérifie que le compte est débiteur
if (strcmp(C.etat, "debiteur") == 0) {
int nb_ajout = 0;
int nb_retrait = 0;
// Parcours les opérations du compte pour compter le nombre d'opérations d'ajout et de retrait
for (int j = 0; j < C.nb_operations; j++) {
if (C.operations[j] > 0) {
nb_ajout++;
} else if (C.operations[j] < 0) {
nb_retrait++;
}
}
// Vérifie que le nombre d'opérations d'ajout est supérieur aux nombres d'opérations de retrait
if (nb_ajout > nb_retrait) {
float prime = (C.solde / C.nb_operations) * 0.5;
printf("RIB : %d - Prime : %.2f\n", C.RIB, prime);
}
}
}
}
//source file/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "header.h"
int main() {
// Initialize the array of accounts
int NC = 0;
// Display the menu and get the user's choice
int choix = menu();
while (choix != 0) {
switch (choix) {
case 1:
Compte C;
getchar();
CreerCompte(&C);
AjouterCompte(T_Compte, &NC, C);
break;
case 2:
// Display the accounts
ListeComptes(T_Compte, NC);
break;
case 3:
// Add or remove money from an account
printf("RIB du compte : ");
int RIB;
scanf("%d", &RIB);
printf("Somme à ajouter ou retirer : ");
float M;
scanf("%f", &M);
float solde = Ajouter_Retirer(T_Compte, NC, M, RIB);
if (solde != -1) {
printf("Nouveau solde : %.2f\n", solde);
}
break;
case 4:
// Attribute a prize to the best accounts
Prime(T_Compte, NC);
break;
}
// Display the menu and get the user's choice again
choix = menu();
}
printf("Au revoir !\n");
return 0;
}
Here is the main function that uses 4 switches to perform the following functions:
Add a new account
Display the accounts of the bank
Add an operation to an account
Attribute a prize to the best accounts
Is this line 17?
Compte C;
If so, you need to scope the variable C. Change the case 1: handler to this:
case 1:
{
Compte C;
getchar();
CreerCompte(&C);
AjouterCompte(T_Compte, &NC, C);
break;
}

Why do I get a segfault when the for loop finishes adding elements to a list?

My code is an algorithm to solve a problem related to the longest-job first. It receives the number of process (num_programas) and for each process it gets an time (instante) and a weight(carga). When i'm inserting on the list it inserts all process but in the last one it gets segmentation fault.
It is sorting normally (i've printed the header each time the loops executes), it just gets segmentation fault in the last execution of the for loop (for instance: num programas = 7, stops working when i = 6)
/*
Vou fazer com lista duplamente encadeada só pra facilitar na funcao proximo. Não vou otimizar porque preciso me livrar
logo pra fazer o projeto e estudar
puta merda que codigo horrivel, espero que o aleardo nao leia. Otimizar depois.
8
74 11
7 20
53 17
78 13
52 11
63 19
89 17
15 20
*/
#include <stdio.h>
#include <stdlib.h>
struct processo
{
int temp;
int carga;
struct processo *next;
struct processo *prev;
};
struct processo *cadastrarProcesso(struct processo *header, int instante, int carga);
struct processo *executarAtividade(struct processo *header, int *tempo_executando);
struct processo *inserirProcessos(struct processo *programa, struct processo *header);
void imprimirLista(struct processo *header);
struct processo *proximo(struct processo *header, int *tempo_executando);
int main()
{
struct processo *header, *aux;
header = NULL;
int num_programas, instante, carga, i, tempo_executando = 0;
scanf("%d", &num_programas);
for (i = 0; i < num_programas; i++)
{
scanf("%d %d", &instante, &carga);
header = cadastrarProcesso(header, instante, carga);
}
/*
Cadastrou e ordenou em ordem de tempo, aí tem que criar uma funcao para ir printando
*/
imprimirLista(header);
for (i = 0; i < num_programas; i++)
{
header = executarAtividade(header, &tempo_executando);
}
return 0;
}
struct processo *cadastrarProcesso(struct processo *header, int instante, int carga)
{
struct processo *aux;
aux = malloc(sizeof(struct processo));
aux->next = NULL;
aux->prev = NULL;
aux->carga = carga;
aux->temp = instante;
header = inserirProcessos(aux, header);
return header;
}
struct processo *inserirProcessos(struct processo *programa, struct processo *header)
{
struct processo *aux;
if (header == NULL)
{
header = programa;
return header;
}
aux = header;
while (aux->next != NULL && programa->temp > aux->temp)
{
aux = aux->next;
}
if (aux == header)
{
// tem que fazer essa verificacao pq ele sai do while tanto se o while->next for nulo e tambem se for maior
if (programa->temp < aux->temp)
{
// insere depois do header, se tornando o novo header
aux->prev = programa;
programa->next = aux;
return programa;
// é o novo header, retorna ele
}
else // insere depois)
{
programa->next = aux->next;
aux->next = programa;
programa->prev = aux;
return header;
}
}
else
{
// vamos ver se ele saiu porque while->next é nulo ou porque é maior
if (programa->temp < aux->temp)
{
(aux->prev)->next = programa;
programa->prev = aux->prev;
programa->next = aux;
aux->prev = programa;
return header;
}
else // maior igual
{
programa->next = aux->next;
programa->prev = aux;
aux->next = programa;
return header;
}
}
}
void imprimirLista(struct processo *header) // funcao auxiliar
{
struct processo *aux;
aux = header;
while (aux != NULL)
{
printf("%d ", aux->temp);
aux = aux->next;
}
}
struct processo *executarAtividade(struct processo *header, int *tempo_executando)
{
// lembrando que já está dentro de um for
struct processo *aux;
if (*tempo_executando == 0)
{
aux = header;
*tempo_executando = aux->temp + aux->carga;
header = aux->next;
printf("%d ", aux->carga); // imprime a carga da saida que foi executada
(aux->next)->prev = NULL;
aux->next = NULL;
free(aux);
return header;
}
else
{
// TODO: reduzir esse codigo zendo tudo dentro do mesmo IF, só olhando a condicao do proximo
aux = proximo(header, tempo_executando); // recebe o que vai ser executado
*tempo_executando = *tempo_executando + aux->carga;
if (aux == header) // se o aux
{
header = aux->next;
printf("%d ", aux->carga);
(aux->next)->prev = NULL;
aux->next = NULL;
free(aux);
return header;
}
else
{
if (aux->next != NULL)
{
(aux->next)->prev = aux->prev;
(aux->prev)->next = aux->next;
}
else
{
(aux->prev)->next = aux->next;
}
printf("%d ", aux->carga);
free(aux);
return header;
}
}
}
struct processo *proximo(struct processo *header, int *tempo_executando)
{
struct processo *aux, *escolhido;
int maior_carga;
aux = header;
maior_carga = aux->carga;
escolhido = aux;
if (aux->temp >= *tempo_executando)
{
//*tempo_executando = *tempo_executando + (aux->temp - *tempo_executando);
return aux;
}
else
{
while (aux->next != NULL && aux->temp < *tempo_executando)
{
aux = aux->next;
if (aux->carga > maior_carga)
{
maior_carga = aux->carga;
escolhido = aux;
}
else if (aux->carga == maior_carga)
{
// o critério de desempate é o menor tempo
if (aux->carga < escolhido->carga)
{
escolhido = aux;
}
}
}
return escolhido;
}
}
In this code:
if (aux == header) // se o aux
{
header = aux->next;
printf("%d ", aux->carga);
(aux->next)->prev = NULL; // crash here with aux->next == NULL
aux->next = NULL;
free(aux);
return header;
}
when you are removing the last element (aux == header), aux->next is NULL and attempting to dereference it causes a crash. You must check that aux->next != NULL before doing that.
P.S. The aux->next = NULL is useless if you immediately call free(aux).

Problem with duplicate data in fgets with structs [duplicate]

This question already has answers here:
Why is “while( !feof(file) )” always wrong?
(5 answers)
Closed 5 months ago.
I have a program that seems to have a problem displaying the data received from a .txt file with fgets
Basically the program is something similar to a CRUD or ABM (in Spanish).
The problem is that when I show the structs from the file, it shows me a duplicate of the last struct.
The code is the following:
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <io.h>
// ==== Estructura Empleado ====
typedef struct
{
int legajo; // Numero de 6 digitos
char nombreApellido[30];
float sueldo; // Aleatorio entre 80k-200k
} Empleado;
// Carga un empleado por teclado; Devuelve un struct Empleado
Empleado cargarEmpleadoPorTeclado();
// Carga un vector de Empleado
void cargarEmpleadosPorTeclado(Empleado empleados[], int cantidadEmpleados);
// Recibe un vector de chars y devuelve un struct Empleado
Empleado parsearEmpleado(char datosSinParsear[50], int largoDatos);
// Carga los empleados desde el archivo al vector empleados[]
void cargarEmpleadosEnVector(Empleado empleados[], int cantidadEmpleados);
// Guarda los empleados en el archivo 'empleados.txt'
void guardarEmpleados(Empleado empleados[], int cantidadEmpleados);
// Muestra los empleados cargados en el vector empleados[]
void mostrarEmpleadosDesdeArchivo(int cantidadEmpleados, int eliminados);
// Busca un empleado por legajo en el archivo 'empleados.txt' y lo 'elimina'
void eliminarEmpleadoPorLegajo(Empleado empleados[], int legajo, int cantidadEmpleados, int * eliminados);
void eliminarEmpleadoVectorPorLegajo(Empleado empleados[], int legajo, int cantidadEmpleados, int *eliminados);
void menu(Empleado empleados[], int cantidadEmpleados);
/* ==== Funcion main ==== */
int main()
{
int cantidadEmpleados = 100;
Empleado empleados[cantidadEmpleados];
menu(empleados, cantidadEmpleados);
return 0;
}
/* ==== Implementaciones ==== */
Empleado cargarEmpleadoPorTeclado()
{
Empleado empleado;
printf("\nIngrese el Nombre y Apellido del empleado: ");
fflush(stdin);
gets(empleado.nombreApellido);
printf("\nIngrese el numero de Legajo del empleado: ");
fflush(stdin);
scanf("%d", &empleado.legajo);
empleado.sueldo = 80000 + rand() % (200000-80000);
return empleado;
}
void cargarEmpleadosPorTeclado(Empleado empleados[], int cantidadEmpleados)
{
for (int i = 0; i < cantidadEmpleados; i++)
{
empleados[i] = cargarEmpleadoPorTeclado();
}
guardarEmpleados(empleados, cantidadEmpleados);
}
Empleado parsearEmpleado(char datosSinParsear[], int largoDatos)
{
Empleado empleado;
int delimitador1 = -1;
int delimitador2 = -1;
char auxiliarLegajo[10] = " ";
char auxiliarNombreApellido[30] = " ";
char auxiliarSueldo[10] = " ";
for(int i = 0; i < largoDatos; i++)
{
// Recorro el string hasta encontrar la primera ocurrencia
// Notese que i = largoDatos es para forzar la salida del for y no sobreescribir el valor de delimitador1
// con la segunda ocurrencia
if(datosSinParsear[i] == ';')
{
delimitador1 = i;
i = largoDatos;
}
}
// Recorro el string a partir de la posicion siguiente de la primera ocurrencia
for (int i = delimitador1 + 1; i < largoDatos; i++)
{
if (datosSinParsear[i] == ';')
{
delimitador2 = i;
}
}
if ((delimitador1 != -1) && (delimitador2 != -1))
{
// Desde 0 hasta delimitador1 tenemos el legajo
for (int i = 0; i < delimitador1; i++)
{
auxiliarLegajo[i] = datosSinParsear[i];
}
// Desde delimitador1+1 hasta delimitador2 tenemos el nombre y apellido
for (int i = delimitador1 + 1; i < delimitador2; i++)
{
auxiliarNombreApellido[i - delimitador1 - 1] = datosSinParsear[i];
}
// Desde delimitador2+1 hasta largoDatos tenemos el sueldo en float
for (int i = delimitador2 + 1; i < strlen(datosSinParsear); i++)
{
auxiliarSueldo[i - delimitador2 - 1] = datosSinParsear[i];
}
empleado.legajo = atoi(auxiliarLegajo);
strcpy(empleado.nombreApellido, auxiliarNombreApellido);
empleado.sueldo = atof(auxiliarSueldo);
return empleado;
}
}
void cargarEmpleadosEnVector(Empleado empleados[], int cantidadEmpleados)
{
// Intentamos abrir el archivo y verificamos si no es un puntero nulo
FILE * archivoEmpleados = fopen("empleados.txt", "r");
if(archivoEmpleados != NULL)
{
int i = 0;
while (!feof(archivoEmpleados) && (i < cantidadEmpleados))
{
char datosSinParsear[50] = "";
Empleado empleadoActual;
// Leemos los datos y lo parseamos
fgets(datosSinParsear, 50, archivoEmpleados);
empleadoActual = parsearEmpleado(datosSinParsear, 50);
// Lo asignamos a la posicion actual del vector 'empleados[]'
empleados[i] = empleadoActual;
i++;
}
fclose(archivoEmpleados);
}
// Si el archivo no existe o no lo encuentra
else
{
printf("\nImposible leer los empleados\nEl archivo \"empleados.txt\" no existe o no se encuentra en la ruta actual");
exit(-1);
}
}
void guardarEmpleados(Empleado empleados[], int cantidadEmpleados)
{
// Intentamos abrir el archivo y verificamos si no es un puntero nulo
FILE * archivoEmpleados = fopen("empleados.txt", "w");
if(archivoEmpleados != NULL)
{
for (int i = 0; i < cantidadEmpleados; i++)
{
// Grabamos los datos linea por linea con el formato 'legajo;nombreapellido;sueldo'
fprintf(archivoEmpleados, "%d;%s;%.2f\n", empleados[i].legajo, empleados[i].nombreApellido, empleados[i].sueldo);
}
printf("\nEmpleados guardados exitosamente en \"empleados.txt\"");
fclose(archivoEmpleados);
}
// Si el archivo no existe o no lo encuentra
else
{
printf("\nImposible guardar los empleados\nEl archivo \"empleados.txt\" no existe o no se encuentra en la ruta actual");
exit(-1);
}
}
void mostrarEmpleadosDesdeArchivo(int cantidadEmpleados, int eliminados)
{
FILE * archivoEmpleados = fopen("empleados.txt", "r");
int i = 0;
while(!feof(archivoEmpleados) && i < (cantidadEmpleados-eliminados))
{
char datosSinParsear[50] = "";
fgets(datosSinParsear, 50, archivoEmpleados);
Empleado empleadoActual;
empleadoActual = parsearEmpleado(datosSinParsear, 50);
printf("\nEmpleado");
printf("\n\t* Numero de legajo: %d", empleadoActual.legajo);
printf("\n\t* Nombre y Apellido: %s", empleadoActual.nombreApellido);
printf("\n\t* Sueldo (en pesos): %.2f", empleadoActual.sueldo);
i++;
}
fclose(archivoEmpleados);
}
/*
Esta funcion no elimina en si la linea que pertenezca al empleado
Sino mas bien, la omitiria cuando la lea, escribiendo un archivo nuevo con el mismo nombre
De esa forma, estariamos haciendo lo mismo
*/
void eliminarEmpleadoPorLegajo(Empleado empleados[], int legajo, int cantidadEmpleados, int *eliminados)
{
// Intentamos abrir el archivo y verificamos si no es un puntero nulo
FILE * archivoEmpleados = fopen("empleados.txt", "r");
// Creamos un nuevo archivo para escribir los datos
FILE * nuevoArchivoEmpleados = fopen("empleados2.txt", "w");
if(archivoEmpleados != NULL)
{
int i = 0;
while (!feof(archivoEmpleados) && i < cantidadEmpleados)
{
char datosSinParsear[50] = "";
Empleado empleadoActual;
// Recibimos los datos y los parseamos
fgets(datosSinParsear, 50, archivoEmpleados);
empleadoActual = parsearEmpleado(datosSinParsear, 50);
/*
Cuando no coincida el legajo, escribe
Si es que llega a coincidir (justamente ese debemos eliminar), no lo escribimos,
simplemente, hacemos una iteración y continuamos el bucle
*/
if (empleadoActual.legajo != legajo)
{
fprintf(nuevoArchivoEmpleados, "%d;%s;%.2f\n", empleadoActual.legajo, empleadoActual.nombreApellido, empleadoActual.sueldo);
i++;
}
else
{
i++;
continue;
};
}
fclose(archivoEmpleados);
fclose(nuevoArchivoEmpleados);
remove("empleados.txt");
rename("empleados2.txt", "empleados.txt");
eliminarEmpleadoVectorPorLegajo(empleados, legajo, cantidadEmpleados, &eliminados);
*eliminados = *eliminados + 1;
printf("\nEmpleado con legajo numero %d eliminado exitosamente", legajo);
}
// Si el archivo no existe o no lo encuentra
else
{
printf("\nImposible eliminar al empleado\nEl archivo \"empleados.txt\" no existe o no se encuentra en la ruta actual");
exit(-1);
}
}
void eliminarEmpleadoVectorPorLegajo(Empleado empleados[], int legajo, int cantidadEmpleados, int *eliminados)
{
int posicionDelElemento = -1;
for (int i = 0; i < cantidadEmpleados; i++)
{
if(empleados[i].legajo == legajo)
{
posicionDelElemento = i;
i = cantidadEmpleados;
}
}
for(int i = posicionDelElemento - 1; i<cantidadEmpleados-1; i++)
{
empleados[i] = empleados[i + 1];
}
cantidadEmpleados--;
}
void menu(Empleado empleados[], int cantidadEmpleados)
{
int sigue = 1;
int eliminados = 0;
int cantidadEmpleadosVar = 0;
printf("\nMenu Empleados\n");
printf("\nOpciones:\n");
printf("\n\t1. Listar los empleados");
printf("\n\t2. Agregar un empleado");
printf("\n\t3. Eliminar un empleado");
printf("\n\t4. Salir");
do
{
int opcion;
int legajo;
printf("\nIngrese opcion > ");
scanf("%d", &opcion);
switch (opcion)
{
case 1:
printf("\nMostrando empleados cargados");
mostrarEmpleadosDesdeArchivo(cantidadEmpleados, eliminados);
break;
case 2:
printf("\nAgregar un empleado:");
printf("\nCuantos empleados desea cargar? > ");
scanf("%d", &cantidadEmpleadosVar);
cargarEmpleadosPorTeclado(empleados, cantidadEmpleadosVar);
break;
case 3:
printf("\nEliminando un empleado:");
printf("\nIngrese el numero de legajo del empleado a eliminar > ");
scanf("%d", &legajo);
eliminarEmpleadoPorLegajo(empleados, legajo, cantidadEmpleados, &eliminados);
break;
case 4:
sigue = 0;
break;
default:
printf("\nLa opcion \"%d\" no es valida, ingrese otra vez\n\n", opcion);
continue;
break;
}
} while (sigue);
}
And the empleados.txt file is the following:
555666;Leandro;80041.00
232433;Juan;80945.00
234443;Antonio;90485.00
119304;Manuel;102943.00
The output is:
Code output linked on imgur
Does anyone know what this error could be?
There are many issues in your code, here are some important ones:
you must not use gets(): read Why is the gets function so dangerous that it should not be used?
you should test the return value of fgets() to determine if a line was read or if end of file has been reached.
using feof() for this purpose as you do is incorrect. You should read Why is “while( !feof(file) )” always wrong?
you should always test for fopen() success before calling any stream function with the FILE pointer.
Also use more spaces for indentation, 4 is recommended for readability.

Wrong output with C program

I'm trying to get this code work:
#include <stdio.h>
#include <conio.h>
#define N 2
typedef struct identite {
char numClient[20];
char nom[20];
char prenom[20];
} Identite;
typedef struct facture {
int numFacture;
Identite personne;
float prix;
int anlimite;
} Facture;
Facture tabFactures[10];
// initialisation ???
Facture saisirFacture() {
Facture uneFacture;
printf("saisissez le numero de la facture: ");
scanf("%d", &uneFacture.numFacture);
printf("saisissez le numero du client: ");
scanf("%s", &uneFacture.personne.numClient);
printf("saisissez le nom du client: ");
scanf("%s", &uneFacture.personne.nom);
printf("saisissez le prenom du client: ");
scanf("%s", &uneFacture.personne.prenom);
printf("saisissez le prix: ");
scanf("%f", &uneFacture.prix);
printf("saisissez anlimite: ");
scanf("%d", &uneFacture.anlimite);
printf("Vous avez renseigné tous les champs, Merci.\n");
return uneFacture;
}
void saisirTabFacture() {
int i;
i = 0;
Facture fi;
while (i < N) {
tabFactures[i] = fi;
saisirFacture(fi);
i++;
}
getch();
}
void afficheFacture(Facture uneFacture) {
printf("le numero de la facture est:%d\n", uneFacture.numFacture);
printf("le numero du client est:%s\n", uneFacture.personne.numClient);
printf("le nom du client est:%s\n", uneFacture.personne.nom);
printf("le prenom du client est:%s\n", uneFacture.personne.prenom);
printf("le prix est:%f\n", uneFacture.prix);
printf("annee limite est:%d\n", uneFacture.anlimite);
getch();
}
void afficheTabFacture() {
Facture fi;
int i;
for (i = 0;i < N - 1;i++) {
tabFactures[i] = fi
afficheFacture(tabFactures);
}
}
int main() {
Facture tabFactures[N];
Facture uneFacture;
printf("la saisie des factures : \n");
saisirTabFacture();
printf("les factures qui vous avez saisi sont:");
afficheTabFacture(tabFactures);
return 0;
}
Everything works fine except the output of the function afficherTabFacture(tabFactures), instead of giving the strings I have entered it gives special characters, or it gives O or empty values. Here is an image:
Could you please help me to solve it?
There are multiple problems in your code:
saisirFacture returns a Facture by value, but you do not store this return value, instead you pass a Facture as an argument in saisirTabFacture.
There is local array tabFactures in main and a global variable by the same name: main and saisirTabFacture are not referring to the same array.
afficheTabFacture should be passed a Facture object, not an array of Facture objects.
Here is a modified version that will prompt for 2 bills and then print them:
#include <stdio.h>
#include <conio.h>
#define N 2
typedef struct identite {
char numClient[20];
char nom[20];
char prenom[20];
} Identite;
typedef struct facture {
int numFacture;
Identite personne;
float prix;
int anlimite;
} Facture;
Facture saisirFacture(void) {
Facture uneFacture;
printf("saisissez le numero de la facture: ");
scanf("%d", &uneFacture.numFacture);
printf("saisissez le numero du client: ");
scanf("%19s", uneFacture.personne.numClient);
printf("saisissez le nom du client: ");
scanf("%19s", uneFacture.personne.nom);
printf("saisissez le prenom du client: ");
scanf("%19s", uneFacture.personne.prenom);
printf("saisissez le prix: ");
scanf("%f", &uneFacture.prix);
printf("saisissez anlimite: ");
scanf("%d", &uneFacture.anlimite);
printf("Vous avez renseigné tous les champs, Merci.\n");
return uneFacture;
}
void saisirTabFacture(Facture tabFactures[]) {
for (int i = 0; i < N; i++) {
tabFactures[i] = saisirFacture();
}
getch();
}
void afficheFacture(Facture uneFacture) {
printf("le numero de la facture est:%d\n", uneFacture.numFacture);
printf("le numero du client est:%s\n", uneFacture.personne.numClient);
printf("le nom du client est:%s\n", uneFacture.personne.nom);
printf("le prenom du client est:%s\n", uneFacture.personne.prenom);
printf("le prix est:%f\n", uneFacture.prix);
printf("annee limite est:%d\n", uneFacture.anlimite);
getch();
}
void afficheTabFacture(Facture tabFactures[]) {
for (int i = 0; i < N; i++) {
afficheFacture(tabFactures[i]);
}
}
int main(void) {
Facture tabFactures[N];
Facture uneFacture;
printf("la saisie des factures : \n");
saisirTabFacture(tabFactures);
printf("les factures qui vous avez saisi sont:");
afficheTabFacture(tabFactures);
return 0;
}

Need some help figuring out how to do 2 things in my C program [closed]

Closed. This question needs to be more focused. It is not currently accepting answers.
Want to improve this question? Update the question so it focuses on one problem only by editing this post.
Closed 7 years ago.
Improve this question
I'm trying to implement 2 things in my program in C. I don't think is necessary to show you the code as I simply want to know if they're possible to be done. I've searched this but couldn't find any clear answer.
I have this program in C, with many functions, main() and 3 "sub menus".
The main is basically just the main menu of the program and it contains a which case to go to the other sub menus, and each of those sub menus go to the functions related to them.
What I want to know is how to make those functions return to those sub menus, instead of going back all the way to main().
In each of those functions I have a "return;" at the end, but they return to main and not the sub menu. It would be great to get some clarity on this.
My other question is if it's possible to go back to the sub menu, before or while entering data in a function from that sub menu, by pressing the backspace key, or maybe give a key the job to, when pressed, cancel the function (as if, I clicked this function by mistake and want to go back) and go back to the sub menu.
I'd really appreciate some help, and if needed I can post the code, or parts of it as it's still pretty big, to give some context (but bare in mind that all the variables, names of the functions, printf's and what not are in portuguese).
EDIT:
Here's the code.
#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
#include <ctype.h>
#define NR 1000
////////////////////////////////////////////////////////////////////////////////
typedef struct
{
int idJogo;
char nomeJogo[50];
char genero[50];
char empresa[50];
char plataforma[50];
long int preco;
int estado; // 1 - Ocupado e 0 - Livre
}jogo;
typedef struct
{
int idCliente;
char nomeCliente[50];
long int contacto;
char cidade[50];
int estado; // 1 - Ocupado e 0 - Livre
}cliente;
typedef struct
{
int idCompra;
int idCliente;
int idJogo;
char nomeJogo[50];
char nomeCliente[50];
char dataCompra[20];
long int valor;
int estado; // 1 - Ocupado e 0 - Livre
}compra;
////////////////////////////////////////////////////////////////////////////////
/////////////////////////////// FICHEIROS //////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
///////////////////////////// Ler Ficheiros ////////////////////////////////////
int lerficheiros (jogo *jogo, cliente *cliente, compra *compra)
{
int m, n, o;
printf("\n\tA carregar os ficheiros...\n\n");
FILE *fj, *fc, *fk;
// Verifica se existe o ficheiro txt dos jogos
if(!(fj=fopen("jogos.txt", "r")))
{
printf("\n\n\tO ficheiro de jogos não existe. <Enter> para criar o ficheiro.");getch();
// Cria o ficheiro caso não exista
fj=fopen("jogos.txt", "w");
printf("\n\tO ficheiro dos jogos foi criado.");
}
// Lê o ficheiro dos jogos
fj=fopen("jogos.txt", "r");
for (m=1; m<NR; m++)
{
fscanf(fj, "%d\n", &jogo[m].idJogo);
fscanf(fj, "%s\n", jogo[m].nomeJogo);
fscanf(fj, "%s\n", jogo[m].genero);
fscanf(fj, "%s\n", jogo[m].empresa);
fscanf(fj, "%s\n", jogo[m].plataforma);
fscanf(fj, "%ld\n", &jogo[m].preco);
fscanf(fj, "%d\n", &jogo[m].estado);
}
fclose(fj);
printf("\n\tFicheiro dos jogos lido <Enter> para continuar.\n");getch();
//Igual para o ficheiro dos clientes
if(!(fc=fopen("clientes.txt", "r")))
{
printf("\n\n\tO ficheiro de clientes não existe. <Enter> para criar o ficheiro.");getch();
// Cria o ficheiro caso não exista
fc=fopen("clientes.txt", "w");
printf("\n\tO ficheiro dos clientes foi criado.");
}
// Lê o ficheiro dos clientes
fc=fopen("clientes.txt", "r");
for (n=1; n<NR; n++)
{
fscanf(fc, "%d\n", &cliente[n].idCliente);
fscanf(fc, "%s\n", cliente[n].nomeCliente);
fscanf(fc, "%ld\n", &cliente[n].contacto);
fscanf(fc, "%s\n", cliente[n].cidade);
fscanf(fc, "%d\n", &cliente[n].estado);
}
fclose(fc);
printf("\n\tFicheiro dos clientes lido <Enter> para continuar.\n");getch();
//Mais uma vez igual para o ficheiro das compras
if(!(fk=fopen("compras.txt", "r")))
{
printf("\n\n\tO ficheiro de compras não existe. <Enter> para criar o ficheiro.");getch();
// Cria o ficheiro caso não exista
fk=fopen("compras.txt", "w");
printf("\n\tO ficheiro de compras foi criado.");
}
// Lê o ficheiro das compras
fk=fopen("compras.txt", "r");
for (o=1; o<NR; o++)
{
fscanf(fk, "%d\n", &compra[o].idCompra);
fscanf(fk, "%d\n", &compra[o].idCliente);
fscanf(fk, "%d\n", &compra[o].idJogo);
fscanf(fk, "%s\n", compra[o].nomeJogo);
fscanf(fk, "%s\n", compra[o].nomeCliente);
fscanf(fk, "%s\n", compra[o].dataCompra);
fscanf(fk, "%ld\n", &compra[o].valor);
fscanf(fk, "%d\n", &compra[o].estado);
}
fclose(fk);
printf("\n\tFicheiro de compras lido <Enter> para continuar.\n");getch();
}
///////////////////////////// Gravar Ficheiros /////////////////////////////////
void gravarficheiros(char sair, jogo *jogo, cliente *cliente, compra *compra)
{
int m, n, o;
FILE *fj, *fc, *fk;
// Grava ficheiro dos jogos
fj=fopen("jogos.txt", "w");
for(m=1;m<NR;m++)
{
if(jogo[m].estado==1)
{
fprintf(fj,"%d\n%s\n%s\n%s\n%s\n%ld\n%d\n",jogo[m].idJogo,jogo[m].nomeJogo,
jogo[m].genero,jogo[m].empresa,jogo[m].plataforma,jogo[m].preco,jogo[m].estado);
}
}
fclose(fj);
// Grava ficheiro dos clientes
fc=fopen("clientes.txt", "w");
for(n=1;n<NR;n++)
{
if(cliente[n].estado==1)
{
fprintf(fc,"%d\n%s\n%ld\n%s\n%d\n",cliente[n].idCliente,cliente[n].nomeCliente,
cliente[n].contacto,cliente[n].cidade,cliente[n].estado);
}
}
fclose(fc);
// Grava ficheiro de compras
fk=fopen("compras.txt", "w");
for(o=1;o<NR;o++)
{
if(compra[o].estado==1)
{
fprintf(fk,"%d\n%d\n%d\n%s\n%s\n%s\n%ld\n%d\n",compra[o].idCompra,compra[o].idCliente,
compra[o].idJogo,compra[o].nomeJogo,compra[o].nomeCliente,compra[o].dataCompra,
compra[o].valor,compra[o].estado);
}
}
fclose(fj);
if (sair=='S') exit(0);
printf("\n\n\n\tFicheiros gravados <Enter> para continuar."); getch();
}
////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////// JOGOS //////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
///////////////////////////// Consultar Jogos //////////////////////////////////
int consultarjogos(jogo *jogo)
{
int n;
system ("cls");
printf("\n----------------------- LISTA DE JOGOS -----------------------\n");
for(n=1;n<NR;n++)
{
if(jogo[n].estado==1)
{
printf("\n\tID: %d | Nome: %s | Genero: %s\n\tEmpresa: %s | ", jogo[n].idJogo, jogo[n].nomeJogo, jogo[n].genero, jogo[n].empresa);
printf("Plataforma: %s | Preco: %ld€\n", jogo[n].plataforma, jogo[n].preco);
}
}
printf("\n--------------------------------------------------------------\n");
printf("\n\tListagem concluída. <Enter> para continuar.");
getch();
}
///////////////////////////// Inserir Jogo /////////////////////////////////////
int inserirjogo(jogo *jogo)
{
int n;
system ("cls");
fflush(stdin);
printf("\n----------------------- INSERIR JOGO -----------------------\n");
for(n=1;n<NR;n++)
{
if(jogo[n].estado!=1)
{
jogo[n].idJogo=rand() % 999;
printf("\n\tNome do Jogo -> "); gets(jogo[n].nomeJogo);
printf("\n\tGenero -> "); gets(jogo[n].genero);
printf("\n\tEmpresa -> "); gets(jogo[n].empresa);
printf("\n\tPlataforma -> "); gets(jogo[n].plataforma);
printf("\n\tPreco (€) -> "); scanf("%ld", &jogo[n].preco); fflush(stdin);
jogo[n].estado=1;
printf("\n\n------------------------------------------------------------\n");
printf("\n\tJogo inserido. <Enter> para continuar.");
getch();
return(0);
}
}
printf("\n\tErro, não foi possivel inserir o jogo. <Enter> para continuar.");
getch(); return(1);
}
/////////////////////////////// Alterar Jogo ///////////////////////////////////
int alterarjogo(jogo *jogo)
{
int n;
long int altjogo;
system("cls");
printf("\n----------------------- ALTERAR JOGO -----------------------\n");
printf("\n\tID do Jogo que pretende alterar: ");
scanf("%d", &altjogo); fflush(stdin);
for(n=1;n<NR;n++)
{
if(jogo[n].idJogo==altjogo)
{
jogo[n].estado=0;
printf("\n\n\tID: %d | Nome: %s | Genero: %s\n\tEmpresa: %s | ", jogo[n].idJogo, jogo[n].nomeJogo, jogo[n].genero, jogo[n].empresa);
printf("Plataforma: %s | Preco: %ld€", jogo[n].plataforma, jogo[n].preco);
printf("\n\n\tNome do Jogo -> "); gets(jogo[n].nomeJogo);
printf("\n\tGenero -> "); gets(jogo[n].genero);
printf("\n\tEmpresa -> "); gets(jogo[n].empresa);
printf("\n\tPlataforma -> "); gets(jogo[n].plataforma);
printf("\n\tPreco (€) -> "); scanf("%ld", &jogo[n].preco); fflush(stdin);
jogo[n].estado=1;
printf("\n\n------------------------------------------------------------\n");
printf("\n\tJogo alterado. <Enter> para continuar.");
getch();
return(0);
}
}
printf("\n\tErro, jogo não encontrado. <Enter> para continuar.");
getch(); return(1);
}
/////////////////////////////// Eliminar Jogo //////////////////////////////////
int eliminarjogo(jogo *jogo)
{
char conf;
int n;
long int elimjogo;
system("cls");
printf("\n----------------------- ELIMINAR JOGO -----------------------\n");
printf("\n\tID do Jogo que pretende eliminar: ");
scanf("%ld", &elimjogo); fflush(stdin);
for(n=1;n<NR;n++)
{
if(jogo[n].idJogo==elimjogo)
{
printf("\n\n\tID: %d | Nome: %s | Genero: %s\n\tEmpresa: %s | ", jogo[n].idJogo, jogo[n].nomeJogo, jogo[n].genero, jogo[n].empresa);
printf("Plataforma: %s | Preco: %ld€", jogo[n].plataforma, jogo[n].preco);
printf("\n\n\tTem a certeza que quer eliminar o jogo? <S/N>");
conf=toupper(getch());
if (conf!='S') return(1);
jogo[n].estado=0;
printf("\n\n-------------------------------------------------------------\n");
printf("\n\tJogo eliminado. <Enter> para continuar.");
getch();
return(0);
}
}
printf("\n\tErro, jogo não encontrado. <Enter> para continuar.");
getch(); return(1);
}
///////////////////////////// Menu Gerir Jogos /////////////////////////////////
int gerirjogos(jogo *jogo)
{
system("cls");
char op;
do {
printf("\n----------------------- GERIR JOGOS -----------------------\n");
printf("\n\t 1 - Consultar Jogos\n\t 2 - Inserir Jogo\n\t 3 - Alterar Jogo\n\t 4 - Eliminar Jogo\n\t 0 - Voltar");
printf("\n\n-----------------------------------------------------------\n");
printf("\n\t Opcao:"); op=getch();
} while(op<'0' || op>'4');
switch (op){
case '1': consultarjogos(jogo); break;
case '2': inserirjogo(jogo); break;
case '3': alterarjogo(jogo); break;
case '4': eliminarjogo(jogo); break;
case '0': return(0); break;
}
}
////////////////////////////////////////////////////////////////////////////////
///////////////////////////////// CLIENTES /////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
////////////////////////// Consultar Clientes //////////////////////////////////
int consultarclientes(cliente *cliente)
{
int n;
system ("cls");
printf("\n----------------------- LISTA DE CLIENTES -----------------------\n");
for(n=1;n<NR;n++)
{
if(cliente[n].estado==1)
{
printf("\n\tID: %d | Nome: %s", cliente[n].idCliente, cliente[n].nomeCliente);
printf("\n\tContacto: %ld | Cidade: %s\n", cliente[n].contacto, cliente[n].cidade);
}
}
printf("\n-----------------------------------------------------------------\n");
printf("\n\tListagem concluída. <Enter> para continuar.");
getch();
}
///////////////////////////// Inserir Cliente //////////////////////////////////
int inserircliente(cliente *cliente)
{
int n;
system ("cls");
fflush(stdin);
printf("\n----------------------- INSERIR CLIENTE -----------------------\n");
for(n=1;n<NR;n++)
{
if(cliente[n].estado!=1)
{
cliente[n].idCliente=rand() % 999;
printf("\n\tNome do Cliente -> "); gets(cliente[n].nomeCliente);
printf("\n\tContacto -> "); scanf("%ld", &cliente[n].contacto); fflush(stdin);
printf("\n\tCidade -> "); gets(cliente[n].cidade);
cliente[n].estado=1;
printf("\n\n---------------------------------------------------------------\n");
printf("\n\tCliente inserido. <Enter> para continuar.");
getch(); return(0);
}
}
printf("\n\tErro, não foi possivel inserir o cliente. <Enter> para continuar.");
getch(); return(1);
}
/////////////////////////////// Alterar Cliente ////////////////////////////////
int alterarcliente(cliente *cliente)
{
int n;
long int altcliente;
system("cls");
printf("\n----------------------- ALTERAR CLIENTE -----------------------\n");
printf("\n\tID do Cliente que pretende eliminar: ");
scanf("%d", &altcliente); fflush(stdin);
for(n=1;n<NR;n++)
{
if(cliente[n].idCliente==altcliente)
{
cliente[n].estado=0;
printf("\n\n\tID: %d | Nome: %s | ", cliente[n].idCliente, cliente[n].nomeCliente);
printf("\n\tContacto: %ld | Cidade: %s", cliente[n].contacto, cliente[n].cidade);
printf("\n\n\tNome do Cliente -> "); gets(cliente[n].nomeCliente);
printf("\n\tContacto -> "); scanf("%ld", &cliente[n].contacto); fflush(stdin);
printf("\n\tCidade -> "); gets(cliente[n].cidade);
cliente[n].estado=1;
printf("\n\n---------------------------------------------------------------\n");
printf("\n\tCliente alterado. <Enter> para continuar.");
getch(); return(0);
}
}
printf("Erro, cliente não encontrado. <Enter> para continuar.");
getch(); return(1);
}
//////////////////////////// Eliminar Cliente //////////////////////////////////
int eliminarcliente(cliente *cliente)
{
char conf;
int n;
long int elimcliente;
system("cls");
printf("\n----------------------- ELIMINAR CLIENTE -----------------------\n");
printf("\n\tID do Cliente que pretende eliminar: ");
scanf("%ld", &elimcliente); fflush(stdin);
for(n=1;n<NR;n++)
{
if(cliente[n].idCliente==elimcliente)
{
printf("\n\n\tID: %d | Nome: %s | ", cliente[n].idCliente, cliente[n].nomeCliente);
printf("\n\tContacto: %ld | Cidade: %s", cliente[n].contacto, cliente[n].cidade);
printf("\n\n\tTem a certeza que quer eliminar o cliente? <S/N>");
conf=toupper(getch());
if (conf!='S') return(1);
cliente[n].estado=0;
printf("\n\n----------------------------------------------------------------\n");
printf("\n\tCliente eliminado. <Enter> para continuar.");
getch();
return(0);
}
}
printf("\n\tErro, cliente não encontrado. <Enter> para continuar.");
getch(); return(1);
}
///////////////////////////// Menu Gerir Clientes //////////////////////////////
int gerirclientes(cliente *cliente)
{
system("cls");
char op;
do {
printf("\n----------------------- GERIR CLIENTES -----------------------\n");
printf("\n\t 1 - Consultar Clientes\n\t 2 - Inserir Cliente\n\t 3 - Alterar Cliente\n\t 4 - Eliminar Cliente\n\t 0 - Voltar");
printf("\n\n--------------------------------------------------------------\n");
printf("\n\t Opcao:"); op=getch();
} while(op<'0' || op>'4');
switch (op){
case '1': consultarclientes(cliente); break;
case '2': inserircliente(cliente); break;
case '3': alterarcliente(cliente); break;
case '4': eliminarcliente(cliente); break;
case '0': return(0); break;
}
}
////////////////////////////////////////////////////////////////////////////////
///////////////////////////////// COMPRAS //////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
///////////////////////////// Consultar Compras ////////////////////////////////
int consultarcompras(compra *compra)
{
int n;
system ("cls");
printf("\n----------------------- REGISTO DE COMPRAS -----------------------\n");
for(n=1;n<NR;n++)
{
if(compra[n].estado==1)
{
printf("\n\tID Compra: %d | ID Jogo: %d | ID Cliente: %d", compra[n].idCompra, compra[n].idJogo, compra[n].idCliente);
printf("\n\tNome do Jogo: %s | Nome do Cliente: %s", compra[n].nomeJogo, compra[n].nomeCliente);
printf("\n\tData da Compra: %s | Valor da Compra: %ld€\n", compra[n].dataCompra, compra[n].valor);
}
}
printf("\n------------------------------------------------------------------\n");
printf("\n\tListagem concluída. <Enter> para continuar.");
getch();
}
///////////////////////////////// Nova Compra //////////////////////////////////
int novacompra(compra *compra, jogo *jogo, cliente *cliente)
{
int n, m, o, idj, idc;
system ("cls");
printf("\n----------------------- NOVA COMPRA -----------------------\n");
for(n=1;n<NR;n++)
{
if(compra[n].estado!=1)
{
compra[n].idCompra=rand() % 999;
printf("\n\tID do Jogo -> "); scanf("%d", &idj); fflush(stdin);
for(m=1;m<NR;m++)
{
if(jogo[m].idJogo == idj)
{
printf("\n\tNome do Jogo: %s", jogo[m].nomeJogo);
compra[n].idJogo = jogo[m].idJogo;
strcpy(compra[n].nomeJogo, jogo[m].nomeJogo);
compra[n].valor = jogo[m].preco;
printf("\n\n\tID do Cliente -> "); scanf("%d", &idc); fflush(stdin);
for(o=1;o<NR;o++)
{
if(cliente[o].idCliente == idc)
{
printf("\n\tNome do Cliente: %s", cliente[o].nomeCliente);
compra[n].idCliente = cliente[o].idCliente;
strcpy(compra[n].nomeCliente, cliente[o].nomeCliente);
printf("\n\n\tData da Compra (dd/mm/aaaa) -> "); scanf("%s", compra[n].dataCompra);
printf("\n\tValor: %ld€", compra[n].valor);
compra[n].estado=1;
printf("\n\n-----------------------------------------------------------\n");
printf("\n\tCompra registada. <Enter> para continuar.");
getch(); return(0);
}
}
}
}
}
}
printf("\n\tErro, não foi possivel concluir a compra. <Enter> para continuar.");
getch(); return(1);
}
//////////////////////////// Eliminar Compra ///////////////////////////////////
int eliminarcompra(compra *compra)
{
char conf;
int n;
long int elimcompra;
system("cls");
printf("\n----------------------- ELIMINAR COMPRA -----------------------\n");
printf("\n\tID da Compra que pretende eliminar: ");
scanf("%ld", &elimcompra); fflush(stdin);
for(n=1;n<NR;n++)
{
if(compra[n].idCompra==elimcompra)
{
printf("\n\n\tID Compra: %d | ID Jogo: %d | ID Cliente: %d", compra[n].idCompra, compra[n].idJogo, compra[n].idCliente);
printf("\n\tNome do Jogo: %s | Nome do Cliente: %s", compra[n].nomeJogo, compra[n].nomeCliente);
printf("\n\tData da Compra: %s | Valor da Compra: %ld€", compra[n].dataCompra, compra[n].valor);
printf("\n\n\tTem a certeza que quer eliminar a compra? <S/N>");
conf=toupper(getch());
if (conf!='S') return(1);
compra[n].estado=0;
printf("\n\n---------------------------------------------------------------\n");
printf("\n\tCompra eliminada. <Enter> para continuar.");
getch();
return(0);
}
}
printf("\n\tErro, registo da compra não encontrado. <Enter> para continuar.");
getch(); return(1);
}
///////////////////////////// Menu Gerir Compras ///////////////////////////////
int gerircompras(compra *compra, jogo *jogo, cliente *cliente)
{
system("cls");
char op;
do {
printf("\n----------------------- GERIR COMPRAS -----------------------\n");
printf("\n\t 1 - Consultar Compras\n\t 2 - Nova Compra\n\t 3 - Eliminar Compra\n\t 0 - Voltar");
printf("\n\n-------------------------------------------------------------\n");
printf("\n\t Opcao:"); op=getch();
} while(op<'0' || op>'3');
switch (op){
case '1': consultarcompras(compra); break;
case '2': novacompra(compra, jogo, cliente); break;
case '3': eliminarcompra(compra); break;
case '0': return(0); break;
}
}
////////////////////////////////////////////////////////////////////////////////
///////////////////////////////// MAIN /////////////////////////////////////////
////////////////////////////////////////////////////////////////////////////////
main()
{
system("COLOR 1F");
char op, sair='N';
int n;
srand(time(NULL));
jogo jogo[NR];
cliente cliente[NR];
compra compra[NR];
system ("chcp 1252");
for(n=1;n<NR;n++)
{
jogo[n].estado=0;
cliente[n].estado=0;
compra[n].estado=0;
}
lerficheiros(jogo, cliente, compra);
for(;;)
{
do
{
system("cls");
printf("\n----------------------- LOJA DE JOGOS -----------------------\n");
printf("\n\t 1 - Gerir Jogos\n\t 2 - Gerir Clientes\n\t 3 - Gerir Compras");
printf("\n\t 4 - Ler Ficheiros\n\t 5 - Gravar Ficheiros \n\t 0 - Sair");
printf("\n\n-------------------------------------------------------------\n");
printf("\n\t Opcao:"); op=getch();
}while (op<'0' || op>'5');
switch (op) {
case '1': gerirjogos(jogo); break;
case '2': gerirclientes(cliente); break;
case '3': gerircompras(compra, jogo, cliente); break;
case '4': lerficheiros(jogo, cliente, compra); break;
case '5': gravarficheiros(sair, jogo, cliente, compra); break;
case '0': sair='S'; gravarficheiros(sair, jogo, cliente, compra);
}
}
}
as far as i understand:
#include <stdio.h>
#include <string.h>
void pause(void);
void print_result(char **menu, int ret);
void clrscr(void);
#define MENU_INPUT(a) menu_input(a,sizeof(a)/sizeof(*a))
char * main_menu[]={
"Display First Menu",
"Display Sencond Menu"
};
char * first_menu[]={
"Format Drive C:",
"Partition First Drive",
"Scan Drive"
};
char * second_menu[]={
"Display an image",
"Play a sound"
};
int menu_input(char **menu,int items){
int i, j;
clrscr();
for(i = 1; i<=items;i++)
printf(" %d - %s\n",i, menu[i-1]);
printf(" 0 - to cancel\n ");
do{
scanf("%d", &i);
}while( i < 0 || i > items);
return i;
}
int main(void){
int ret;
for( ; ; ){
switch( MENU_INPUT( main_menu ) ){
case 0:
return 0;
case 1:
ret = MENU_INPUT( first_menu );
print_result( first_menu, ret );
break;
case 2:
ret= MENU_INPUT(second_menu);
print_result( second_menu, ret );
}
}
return 0;
}
// these are some helpper functions
void pause(void){
char c;
printf("press enter to continue\n");
scanf(" %c", &c);
}
void print_result(char **menu, int ret){
if( ret ){
printf("You pressed %d (%s)\n", ret, first_menu[ ret - 1 ] );
pause();
}
}
// clear screen
void clrscr(void){
#ifdef WIN32
char *cmd = "cls";
#else
char *cmd = "tput reset";
#endif
system(cmd);
}

Resources