how to add a dynamic vector (using pointer) in struct - c

I'm doing a data structure question where it simulates a binary search tree for a student system, however in the part of adding subjects I found the following problem.
problem when trying to add courses
I would like to know what is wrong, or if there is a simpler way to add the subjects,remembering that the disciplines are in a vector of structs.
create student function
void criar_aluno(int matricula,char *nome,int numdisciplinas){
Aluno *novo = malloc(sizeof(Aluno));
novo -> matricula = matricula;
novo -> nome = nome;
novo -> esq = NULL;
novo -> dir = NULL;
//Criando as disciplinas do aluno
novo -> disciplinas = malloc(sizeof(Disciplina) * numdisciplinas);
for (int i = 0; i < numdisciplinas; i++){
printf("Digite o nome da disciplina: ");
scanf("%s",&novo -> disciplinas[i] -> nome);
scanf("%c");
printf("\nDigite o codigo da disciplina: ");
scanf("%d",&novo -> disciplinas[i] -> codigo);
printf("\nDigite a nota final da disciplina: ");
scanf("%f",&novo -> disciplinas[i] -> nota);
}
adicionar_aluno(novo);
}
full code
#include <stdio.h>
#include <stdlib.h>
typedef struct disciplina{
int codigo;
char *nome;
float nota;
}Disciplina;
typedef struct aluno{
int matricula;
char *nome;
struct aluno *esq;
struct aluno *dir;
Disciplina *disciplinas;
}Aluno;
Aluno *raiz = NULL;
Aluno* buscar_aluno(int matricula, Aluno *aux){
if(aux == NULL){
return NULL; //vazia
}else if(matricula == aux->matricula){
return aux; //encontrei :D
}else if(matricula<aux->matricula){ //buscar no lado esq
if(aux->esq != NULL){
return buscar_aluno(matricula, aux->esq);
}else{//esq esta vazia
return aux; //pai do elemento que não foi encontrado
}
}else{//buscar no lado dir
if(aux->dir != NULL){
return buscar_aluno(matricula, aux->dir);
}else{//dir esta vazia
return aux; //pai do elemento que não foi encontrado
}
}
}
void adicionar_aluno(Aluno *aluno){
Aluno *aux = buscar_aluno(aluno -> matricula, raiz);
//Testando se a matricula já existe dentro da árvore
if (aux != NULL && aux -> matricula == aluno -> matricula){
printf("Operacao invalida \n");
}else{
//Se a árvore estiver vazia
if(aux == NULL){
raiz = aluno;
}else{
//Se a matricula for menor que a matricula do pai ele ira para a esquerda
if(aluno -> matricula < aux -> matricula){
aux -> esq = aluno;
}else{ //Se a matricula for maior que a matricula do pai ele ira para a direita
aux -> dir = aluno;
}
}
}
}
void criar_aluno(int matricula,char *nome,int numdisciplinas){
Aluno *novo = malloc(sizeof(Aluno));
novo -> matricula = matricula;
novo -> nome = nome;
novo -> esq = NULL;
novo -> dir = NULL;
//Criando as disciplinas do aluno
novo -> disciplinas = malloc(sizeof(Disciplina) * numdisciplinas);
for (int i = 0; i < numdisciplinas; i++){
printf("Digite o nome da disciplina: ");
scanf("%s",&novo -> disciplinas[i] -> nome);
scanf("%c");
printf("\nDigite o codigo da disciplina: ");
scanf("%d",&novo -> disciplinas[i] -> codigo);
printf("\nDigite a nota final da disciplina: ");
scanf("%f",&novo -> disciplinas[i] -> nota);
}
adicionar_aluno(novo);
}
void buscar_dados(int matricula){
Aluno *aux = buscar_aluno(matricula, raiz);
if (aux -> matricula != matricula){
printf("Aluno nao encontrado \n");
}else{
printf("Matricula do aluno: %d | Nome do aluno: %s ",aux -> matricula, aux -> nome);
printf("Nome da disciplina: %s | Codigo da disciplina: %d | Nota final da disciplica: %f", aux -> disciplinas -> nome, aux -> disciplinas -> codigo, aux -> disciplinas -> nota);
}
}
Aluno* remover_aluno(int matricula, Aluno *aux){
if(aux == NULL){
printf("Valor nao encontrado!\n");
return NULL;
} else { // Procurando o nó para remover
if(aux->matricula == matricula) {
// Remove nós folhas (sem filhos)
if(aux->esq == NULL && aux->dir == NULL) {
free(aux);
return NULL;
}else if(aux -> esq != NULL && aux -> dir != NULL){
//Removendo nós com dois filhos
}else{
//Removendo nós com apenas um filho
Aluno *filho;
if(aux -> esq != NULL){
filho = aux -> esq;
}else{
filho = aux -> dir;
}
free(aux);
return filho;
}
}else{
if(matricula < aux -> matricula){
aux -> esq = remover_aluno(matricula, aux -> esq);
}else{
aux -> dir = remover_aluno(matricula, aux -> dir);
}
return aux;
}
}
}
void in_ordem(Aluno* aux){
if (aux != NULL){
in_ordem(aux -> esq);
printf("%d ", aux -> matricula);
in_ordem(aux -> dir);
}
}
int main(){
criar_aluno(20,"Joao",1);
// criar_aluno(10,"Pedro",2);
// criar_aluno(30,"Vitor",3);
// criar_aluno(40,"Ana",2);
// criar_aluno(5,"Vitoria",3);
// in_ordem(raiz);
// printf("\n");
//remover_aluno(10,raiz);
//in_ordem(raiz);
//buscar_dados(20);
return 0;
}
I tried to create a dynamic vector using a pointer and add it to each repetition index, since I have as input to the function the number of subjects that each student will complete.
novo -> disciplinas = malloc(sizeof(Disciplina) * numdisciplinas);
for (int i = 0; i < numdisciplinas; i++){
printf("Digite o nome da disciplina: ");
scanf("%s",&novo -> disciplinas[i] -> nome);
scanf("%c");
printf("\nDigite o codigo da disciplina: ");
scanf("%d",&novo -> disciplinas[i] -> codigo);
printf("\nDigite a nota final da disciplina: ");
scanf("%f",&novo -> disciplinas[i] -> nota);
}

you need
scanf("%s", &novo->disciplinas[i].nome);
discplinas is an array, disciplina[i] is an instance of Discpilna

Related

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).

Error 'listaCliente' undeclared (first use in this function)

I can't run the code because it gives the error mentioned in the title, but I declared it in main. I'm stuck for a few hours and I can't solve this
main.c , here is where I declare the "listaCliente"
int main()
{
Cliente* listaCliente = lerBaseDeDados();
menuPrincipal(listaCliente);
}
Cliente.c // menu , basically this is going to be a menu to manage clients (add remove consult), but I don't understand why it's giving me an error in the line menuPrincipal(listaCliente);
void submenuGGestaoClientes()
{
int continuar=-1;
int aux=-1;
do {
printf("---------------- Gestao Clientes ----------------\n\n");
printf("1- Adicionar Cliente\n");
printf("2- Remover Cliente \n");
printf("3- Consultar Clientes \n");
printf("0- Retroceder \n\n");
printf("-------------------------------------------------\n");
do
{
fflush(stdin);
if(scanf("%d", &aux) != 0){
continuar = aux;
}
if(continuar < 0 || continuar > 3) {
system("cls || clear");
printf("erro, opcao invalida!\n");
printf("---------------- Gestao Clientes ----------------\n\n");
printf("1- Adicionar Cliente\n");
printf("2- Remover Cliente \n");
printf("3- Consultar Clientes \n");
printf("0- Retroceder \n\n");
printf("-------------------------------------------------\n");
}
} while(continuar < 0 || continuar > 3 );
switch(continuar)
{
case 1:
adicionar(listaCliente);
break;
case 2:
printf("Arroz");
break;
case 3:
printf("Arroz");
break;
case 0:
menuPrincipal(listaCliente); //where have the 1º error
break;
default:
printf("Digite uma opcao valida\n");
break;
}
printf("\n");
system("pause");
} while(continuar != 0);
}
Cliente.c function "adicionar" basically it's a function that will add the customer data
void adicionar(Cliente* listaCliente) {
Cliente* novoCliente = (Cliente*)calloc(1, sizeof(Cliente));
int auxInt = -1;
char auxNome, auxMorada;
int escolha = -1;
//Menu para escolher o tipo do contentor, a resposta e recolhida com um switch case
printf("Digite o nome do Cliente: \n");
scanf("%c", &auxNome);
novoCliente->nome = auxNome;
printf("Digite o numero de cartao do cliente:\n");
do {
auxInt = -1;
fflush(stdin);
if(scanf("%d", &auxInt) != 0){
novoCliente->num_cartao = auxInt;
}
if(auxInt < 0 ) {
printf("erro, Numero de cartao invalido!\n");
}
} while(auxInt < 0 );
printf("Digite o numero de cliente:\n");
do {
auxInt = -1;
fflush(stdin);
if(scanf("%d", &auxInt) != 0){
novoCliente->num_cliente = auxInt;
}
if(auxInt < 0 ) {
printf("erro, Numero de cliente invalido!\n");
}
} while(auxInt < 0 );
printf("Digite o numero de contribuinte do cliente:\n");
do {
auxInt = -1;
fflush(stdin);
if(scanf("%d", &auxInt) != 0){
novoCliente->num_cartao = auxInt;
}
if(auxInt < 0 || auxInt > 9999999) {
printf("erro, Numero de Contribuinte invalido!\n");
}
} while(auxInt < 0 );
printf("Digite a morada do Cliente: \n");
scanf("%c", &auxMorada);
novoCliente->morada = auxMorada;
listaCliente = adicionarCliente(listaCliente, novoCliente);
printf("\nAdicionado com sucesso!\n");
}
At least within the function submenuGGestaoClientes declared like
void submenuGGestaoClientes();
there is used the undeclared name listaCliente:
adicionar(listaCliente);
or
menuPrincipal(listaCliente);
Maybe you mean the following function declaration
void submenuGGestaoClientes( Cliente* listaCliente );
Pay attention to that such a call
fflush(stdin);
has undefined behavior. Remove such statements.
Also rewrite this call of scanf
scanf("%c", &auxNome);
like
scanf(" %c", &auxNome);
^^^^
The leading space in the format string allows to skip white space characters in the input buffer.

I have some problems with linked lists

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);
}

Error ! null list

I have a problem, my code is executing option 3 only the first time, if I go back to the menu and try again appears nulla. Case 3 is to list a list of names in alphabetical alphabetical order and reverse order (InsertOrd 0 / InsertDec 1);
Here is the code:
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <locale.h>
#define N 10000
typedef struct Lista {
char *data;
struct Lista *next;
} Lista;
//Ordem Crescente
struct Lista *InsertOrd(struct Lista *head, const char *data) {
struct Lista *newp;
struct Lista *tmp;
char *new_data;
/* aloca o novo item */
newp = ((struct Lista*)malloc(sizeof(struct Lista)));
new_data = strdup(data);
//strdup aloca memória na pilha.
if (newp == NULL || new_data == NULL) {
fprintf(stderr, "out of memory");
return NULL;
}
newp->data = new_data;
newp->next = NULL;
/* check if element should be inserted at the head */
if (head == NULL || strcmp(new_data, head->data) < 0) {
newp->next = head;
head = newp;
} else {
/* otherwise find the point of insertion */
tmp = head;
while (tmp->next && strcmp(new_data, tmp->next->data) >= 0) {
tmp = tmp->next;
}
newp->next = tmp->next;
tmp->next = newp;
}
return head;
}
//Ordem decrescente
struct Lista *InsertDec(struct Lista *head, const char *data) {
struct Lista *newp;
struct Lista *tmp;
char *new_data;
/* aloca o novo item */
newp = ((struct Lista*)malloc(sizeof(struct Lista)));
new_data = strdup(data);
//strdup aloca memória na pilha.
if (newp == NULL || new_data == NULL) {
fprintf(stderr, "out of memory");
return NULL;
}
newp->data = new_data;
newp->next = NULL;
/* verificar o elemento deve ser inserido na cabeça*/
if (head == NULL || strcmp(new_data, head->data) < 0) {
newp->next = head;
head = newp;
} else {
/* caso contrário, encontre o ponto de inserção */
tmp = head;
while (tmp->next && strcmp(new_data, tmp->next->data) <= 0) {
tmp = tmp->next;
}
newp->next = tmp->next;
tmp->next = newp;
}
return head;
}
void liberar(struct Lista *filmes)
{
while (filmes != NULL) {
struct Lista *next = filmes->next;
free(filmes->data);
free(filmes);
filmes = next;
}
}
void escrever(struct Lista * film,struct Lista * filmes)
{
for (film = filmes; film != NULL; film = film->next) {
printf("\n Nome: %s", film->data);
}
}
int main()
{
struct Lista *filmes;
struct Lista *film;
FILE *arq;
char linha[600];
int opcao;
/* insert the items */
filmes = NULL;
/* open the file */
arq = fopen("asd.txt", "r");
if (arq == NULL) {
printf("Ocorreu um erro!");
return 1;
}
do{
printf("\n1- Listar todos os atores da lista em ordem alfabetica e alfabetica reversa");
printf("\n2- Listar todos os filmes de um determinado ator em ordem cronologica.");
//\n Os filmes que não tiverem a informação de ano são mostrados em último lugar
printf("\n3- Listar todos os filmes em ordem alfabetica e alfabetica reversa");
printf("\n4- Inserir novo filme");
printf("\n5- Remocao de filmes");
printf("\n6-SAIR DO PROGRAMA");
printf("\n");
scanf("%d",&opcao);
if(opcao<1 || opcao>6){
printf("\nO numero que voce digitou eh invalido!\n Por favor tente novamente.\n");
}
switch(opcao)
{
case 1:
break;
case 2:
break;
case 3:
printf("\n Voce gostaria de listar em ordem alfabetica ou alfabetica reversa (0/1) :");
int op;
scanf("%d",&op);
if(op!=0 && op!=1)
{
printf("\n Voce precisa digita o numero 1 ou 0 apenas!\n");
}
switch(op){
case 0:
while (fgets(linha, sizeof linha, arq)) {
char *p = strtok(linha, ",");
filmes = InsertOrd(filmes, p);
}
fclose(arq);
escrever(film,filmes);
liberar(filmes);
break;
case 1:
while (fgets(linha, sizeof linha, arq)) {
char *p1 = strtok(linha, ",");
filmes = InsertDec(filmes, p1);
}
fclose(arq);
escrever(film,filmes);
liberar(filmes);
break;
}
break;
case 4:
break;
case 5:
break;
case 6:
printf("\nSaindo do programa...");
break;
}
}while(opcao!=6);
// escrever(film,filmes);
/* free the list */
while (filmes != NULL) {
struct Lista *next = filmes->next;
free(filmes->data);
free(filmes);
filmes = next;
}
return 0;
}
The first time I run either option 1 or 0 of case 3 works but then this appears:
You have only one
arq = fopen("asd.txt", "r");
and you have several
fclose(arq);
Option 3 (both cases) does
while (fgets(linha, sizeof linha, arq))
// ...
fclose(arq);
So next time you use option 3 - it fails.
I suggest that instead of fclose in those options, you add rewind before reading.
Please test your code step by step as you build it.

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