Erro a gravar em ficheiro

[jppbasilio 0]

boas.

o seguinte codigo esta me a dar erro. nao sei bem porque mas penso k seja da funcao gravar_cenario

se alguem me poder ajudar agradecia desde ja

btw tou a usar o VS 2010

 

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

typedef struct entradas_saidas
{
	int num_entradas;
	int num_saidas;
}*ENTRADAS_SAIDAS;

typedef struct no
{
	int n_no;
	int num_entradas;
	int num_saidas;
	int dist_anterior;	
	struct no *seg, *ant;
}*NO;

typedef struct lista_nos
{
	int num_nos;
	NO no_inicio;
	NO no_fim;
}*LISTA_NOS;

typedef struct via
{
	int num_via;
	LISTA_NOS info;
	struct via *seg; 
}*VIA;

typedef struct lista_vias 
{
	int n_vias;
	VIA primeira;
}*LISTA_VIAS;

typedef struct estado
{
	int est;
}ESTADO;


LISTA_VIAS criar_lista_vias()
{
	LISTA_VIAS LV;
	LV = (LISTA_VIAS)malloc(sizeof(struct lista_vias));
	LV->primeira = NULL;//ainda não existe informação sobre o 1º nó
	LV->n_vias = 0; //ainda não foram inseridas vias. Campo "total_vias" da estrutura "lista_vias" inicia-se a 0.
	return LV;
}

NO criar_no()
{
	NO N;
	N = (NO)malloc(sizeof(struct no));
	N->n_no = 0;
	N->num_entradas = 0;
	N->dist_anterior = 0;
	N->num_saidas = 0;
	N->ant = NULL;
	N->seg = NULL;
	return N;
}

LISTA_NOS criar_lista_nos()
{
	LISTA_NOS LN;
	LN = (LISTA_NOS)malloc(sizeof(struct lista_nos));
	LN->num_nos=0;
	LN->no_inicio = NULL;//criar_no(); // não existe nó de inicio
	LN->no_fim = NULL;
	return LN;
}

VIA criar_via()
{
	VIA V;
	V = (VIA)malloc(sizeof(struct via)); //alocar estrutura VIA
	V->num_via=0;
	V->info=criar_lista_nos(); 
	V->seg = NULL;
	return V;
}


ESTADO *alocar_memoria(int n)
{
	ESTADO *p;
	p=(ESTADO *) malloc(n*sizeof(ESTADO));
	return p;
}

void editar_via(LISTA_VIAS lv, VIA v)
{
	int i;
	NO n;
	printf("[via %d]\n",v->num_via);
	printf("numero nos: %d\n",v->info->num_nos);
	n= v->info->no_fim; //indica que n é o nó de inicio
	for(i=v->info->num_nos; i>0; i--)
	{
		printf("\n\nno %d\n",n->n_no);
		printf("dist: %d\n",n->dist_anterior);
		printf("entradas: %d\n",n->num_entradas);
		printf("Saidas: %d\n",n->num_saidas);
		n=n->ant;
	}
}

NO pesquisar_no(LISTA_NOS ln, int n)
{
	int x=1, i;
	NO no_pesquisar = ln->no_inicio;//começa a pesquisar pelo nó de inicio
	while(x)
	{	
		if(no_pesquisar->n_no == n) //se o nº do nó_pesquisar é igual ao numero do nó actual
		{
			return no_pesquisar; //devolve o nó pesquisado
			x=0;
		}
		else
			no_pesquisar = no_pesquisar->seg; // passa ao nó seguinte
	}
}


NO inserir_no_lista(LISTA_NOS ln, NO n)
{
	if(n->n_no==1) // se estamos no nó 1, então é o nó de inicio.
		ln->no_inicio = n;
	else{
		ln->no_fim = n; // o nó actual é agora o nó de fim
		n->ant = pesquisar_no(ln, ((n->n_no)-1)); //vai pesquisar quem é o nó anterior ao nó actual, e coloca-o no campo ant
	}
	return n;
}

void ler_no(LISTA_NOS ln, NO n, int num_no)
{
	printf("\n NO %d:",num_no);
	n->n_no = num_no;
	if(n->n_no==1)
	{
		printf("\n  Distancia desde o inicio (Km): 0\n");
		n->dist_anterior = 0;
	}
	else
	{
		do{
			printf("\n  Distancia desde o inicio (Km): ");
			scanf("%d",&(n->dist_anterior));
		}while(n->dist_anterior <= pesquisar_no(ln, num_no-1)->dist_anterior); 
		//NOTA: como o nó actual ainda não foi inserido na lista, ainda não sabe quem é o nó anterior.
		//      por isso, para verificar se a distancia do nó actual é <= que o nó anterior, faz-se a 
		//      pesquisa a quem é o nó anterior e vai-se buscar o valor da distancia desse nó.     
	}
	do{				
		printf("  Numero entradas: ");
		scanf("%d", &(n->num_entradas));
	}while(n->num_entradas<1);
	
	do{
		printf("  Numero saidas: ");
		scanf("%d", &(n->num_saidas));
	}while(n->num_saidas<1);
}


void ler_via(LISTA_VIAS lv, VIA v)
{
	int i, j;
	//NO n;
	printf("\n\n [VIA %d]\n\n", ++lv->n_vias);
	v->num_via = lv->n_vias; //envia o numero do total de vias para o campo "nº via"
	do{
		printf("  Insira o numero de nos da via: ");
		fflush(stdin);
		scanf("%d", &v->info->num_nos);
	}while(v->info->num_nos<2);

	for(i=1 ; i<=(v->info->num_nos); i++)
	{
		NO n = criar_no();
		ler_no(v->info, n, i);
		inserir_no_lista(v->info, n); //insere o nó no na lista e identifica quem é o no inicio e o no de fim
		n = n->seg; //passa ao nó seguinte		
	}
	printf("\n\nno inicio %d", v->info->no_inicio->n_no);
	printf("\nno fim %d", v->info->no_fim->n_no);
	editar_via(lv,v);
}

int comparar_vias(VIA A, VIA B) 
{
	VIA VA, VB;
	VA = (VIA) A->num_via;
	VB = (VIA) B->num_via;
	return (VA==VB);
}

void inserir_via_lista(LISTA_VIAS LV, VIA via_nova) 
{
	int av=1;
	VIA ant,act; // as variaveis ant e act vao permitir correr a listagem dos elementos á procura do local correcto
	if (LV->primeira==NULL) // se a lista ainda está vazia
	{
		via_nova->seg=NULL;//o campo seguinte passa a estar a null (nao ha seguinte)
		LV->primeira=via_nova;//insere a via no inicio
	} 
	else  // Se já existem elementos na lista
	{
		ant=act=LV->primeira; // as variaveis ant e act começam no inicio para percorrerem a lista até ao fim

		while(av)
			if(act==NULL) // se o campo act for o ultimo da lista (NULL), o campo avanço passa a 0 e sai do while (a via fica no fim da lista)
				av=0;
			else if((act->num_via, via_nova->num_via)>0)//compara as vias, e se encontrar o seu lugar, pára
			//else if(comparar_vias(act, via_nova)>0) 
			av=0;
		else // se ainda não tiver encontrado o seu lugar, avança
		{ 
			ant=act; //o campo anterior passa ao actual
			act=act->seg; // e o campo actual passa ao seguinte
		}
		if(act==LV->primeira)
		{
			via_nova->seg=LV->primeira; 
			LV->primeira=via_nova; 
		} 
		else 
		{
			ant->seg=via_nova;
			via_nova->seg=act;
		}
		
	}
	//NOTA: Não precisa fazer a adicao de mais um elemento pois já o fez na leitura dos dados.
}

/*
void editar_via(LISTA_VIAS lv, VIA v)
{
	int i;
	printf("[via %d]\n",v->num_via);
	printf("numero nos: %d\n",v->info->num_nos);
	NO n = v->info->no_fim; //indica que n é o nó de inicio
	for(i=1; i<=v->info->num_nos; i--)
	{
		printf("\n\nno %d\n",n->n_no);
		printf("dist: %d\n",n->dist_anterior);
		printf("entradas: %d\n",n->num_entradas);
		printf("Saidas: %d\n",n->num_saidas);
		n=n->ant;
	}
}*/


//************************************************ GRAVAR E LER FICHEIROS *********************************************************


void gravar_cenario(LISTA_VIAS LV) 
{
	int num_no, i;
	VIA v;
	NO n;
	FILE *fich = fopen("C:/Users/Julio/Documents/Visual Studio 2010/Projects/codigo/codigo/cenario.ini", "a"); // escreve o ficheiro

	fprintf(fich, "%d\n", LV->n_vias); //escreve no inicio do ficheiro o total de vias
	v = LV->primeira;
	while (v)                       
	{
		fprintf(fich, "%d\n",v->num_via);
		fprintf(fich, "%d\n",v->info->num_nos);

		n = v->info->no_inicio; //indica que n é o nó de inicio
		//while(n)
		//{
		for(i=1; i<=v->info->num_nos; i++)
		{
			fprintf(fich, "%d\n",n->n_no);
			fprintf(fich, "%d\n",n->dist_anterior);
			fprintf(fich, "%d\n",n->num_entradas);
			fprintf(fich, "%d\n",n->num_saidas);
			n = n->seg;
		}
		v = v->seg;
	}
	fclose(fich);
}


void ler_cenario(LISTA_VIAS lv)
{
	int num_no, i, j;
	FILE *fich=fopen("C:/Users/Julio/Documents/Visual Studio 2010/Projects/codigo/codigo/cenario.ini", "r");

	if(!fich) // se nao foi possivel abrir o ficheiro
	{
		fprintf(stderr, "\n ERRO: Ficheiro config.ini nao encontrado ou insercao de via pela 1a vez.");
		
	}
	else 
	{

		fscanf(fich, "%d", &lv->n_vias); //vai buscar o nº de vias total

		for(i=0; i<lv->n_vias; i++)                       //irá listar as vias
		{
			VIA v = criar_via();  // cria e inicializa a via
			fscanf(fich, "%d",&v->num_via); // envia 
			fscanf(fich, "%d",&v->info->num_nos);
			
			//NO n = v->info->no_inicio;
			for(j=0; j<v->info->num_nos; j++)
			{
				NO n = criar_no();
				fscanf(fich, "%d",&n->n_no);
				fscanf(fich, "%d",&n->dist_anterior);
				fscanf(fich, "%d",&n->num_entradas);
				fscanf(fich, "%d",&n->num_saidas);
				inserir_no_lista(v->info, n);
				n = n->seg;// = criar_no();
			}
			inserir_via_lista(lv, v);
			v = v->seg;//passa a escrita da via seguinte
		}
		fclose(fich);
	}
}

void gravar_config(ESTADO *e, int n)
{
	FILE *fich = fopen("config.ini", "w");

	if(!fich)
		fprintf(stderr, "\a\nNao foi possivel gravar o ficheiro. \n");
	else{
		fprintf(fich,"%d\n",*e);
		fclose(fich);
	}
}

void ler_config(ESTADO *e, int n)
{
	FILE *fich;

	if((fich=fopen("config.ini", "r"))==NULL)
		fprintf(stderr, "\n                                     | Estado Actual: NAO DEFINIDO       |");
		//fprintf(stderr, "\n | Estado Actual: NAO DEFINIDO                                      |");
	else 
	{
		fscanf(fich,"%d",&*e);
		fclose(fich);
	}
}

void apagar_historico()
{
	FILE *fich = fopen("simulacao.txt", "w");

	if(!fich)
	{
		printf("\n   *-----------------------------------------------------------*");
		printf("\n   | ERRO: Nao existe ficheiro para limpar.                    |");
		printf("\n   *-----------------------------------------------------------*\n\n\n");
		//NOTA: se acontecer que o ficheiro nao exista, visto que foi aberto para escrita no inicio da 
		//      funcao, cria o ficheiro e deixa-o vazio
	}
	else
		fclose(fich);//fecha o ficheiro sem registar nada
}


void mostrar_estado(ESTADO *E)
{
	if ((E->est)==1)
		//printf("\n | Estado Actual: INICIADO                                          |");
		printf("\n                                     | Estado Actual: INICIADO           |");
	else if((E->est)==2)
		printf("\n                                     | Estado Actual: EM PAUSA           |");
		//printf("\n | Estado Actual: EM PAUSA                                          |");
	else if((E->est)==3)
		printf("\n                                     | Estado Actual: DESLIGADO          |");
		//printf("\n | Estado Actual: DESLIGADO                                         |");
}



//***************************************************** PESQUISAR *******************************************************

VIA pesquisar_via(LISTA_VIAS lv, int n)
{
	int x=1, i;
	VIA via_pesquisar; //cria a variavel que irá conter a informação da via pesquisada
	via_pesquisar = lv->primeira; //indica que a via_pesquisar corresponde á 1a via da lista
	while(x)
	{	
		if(via_pesquisar->num_via == n) //se o nº da via da lista é igual ao numero pesquisado
		{
			return via_pesquisar; //devolve a via pesquisada
			x=0;
		}
		else
		via_pesquisar = via_pesquisar->seg;
	}
	//NOTA: chega a esta função 2 informacoes: LISTA_VIAS e o nº da via pesquisada.
	//      esta funcao tem de ir á procura da via com o nº pesquisado, e devolver á main toda a informacao da via
}


//************************************************ REMOVER ****************************************************

void libertar_via(VIA via_libertar)
{
	free(via_libertar->info); // liberta a lista_vias
	free(via_libertar); //liberta a via
}



VIA remover_via(LISTA_VIAS lv, VIA via_remover) 
{
	int av=1;
	VIA ret,ant,act;
	if (lv->primeira==NULL)
		ret=NULL;
	else {
		ant=act=lv->primeira;
		while(av)
			if(act==NULL)
				av=0;
			else if(act == via_remover)
				av=0;
			else {
				ant=act;
				act=act->seg;
			}
			if(act!=NULL) {
				ret=act;
				if(lv->primeira==act)
					lv->primeira=act->seg;
				else
					ant->seg=act->seg;
				lv->n_vias--;
			}else
				ret=NULL;
	}
	return ret;
	
}

void destruir_lista_vias(LISTA_VIAS lv) 
{
	FILE *fich; 
//  NOTA:Sempre que é escolhida uma opção do menu "Criar ou Editar cenário", exite leitura do ficheiro. Como tal, se o ficheiro for 
	free(lv->primeira);
	lv = criar_lista_vias(); // volta a inicializar a lista de vias, criando tudo de novo
	if(lv->primeira==NULL)
	{
		printf("\n   *-----------------------------------------------------------*");
		printf("\n   | Todas as vias foram removidas com sucesso!                 |");
		printf("\n   *-----------------------------------------------------------*\n\n\n");
		fich=fopen("cenario.ini", "w"); //limpa ficheiro
		fclose(fich);
	}
	else
	{
		printf("\n   *----------------------------------------------------------------*");
		printf("\n   | ERRO: Nao foi possivel apagar as vias. Nenhuma via apagada     |");
		printf("\n   *----------------------------------------------------------------*\n\n\n");
		editar_via(lv, lv->primeira);
	}
}


void remover_via_confirmar(LISTA_VIAS lv, int n)
{

	char op;
	VIA via_pesquisada;

	if(lv->primeira==NULL) //se ainda nao existirem vias adicionadas
	{
		printf("\n   *-----------------------------------------------------------*");
		printf("\n   | ERRO: Nao existem vias adicionadas para poder eliminar.   |");
		printf("\n   *-----------------------------------------------------------*\n\n\n");
	}
	else 
		if(n>lv->n_vias || n<=0)
		{
			printf("\n   *-----------------------------------------------------------*");
			printf("\n   | ERRO: A via que indicou nao existe.                       |");
			printf("\n   *-----------------------------------------------------------*\n\n\n");
		}
		else
		{
			printf("\n   *-----------------------------------------------------------*");
			printf("\n   | Ira perder toda a informacao da via e a numeracao das     |");
			printf("\n   | vias sera corrigida. Pretende continuar?(S/N)             |");
			printf("\n   *-----------------------------------------------------------*");
			printf("\n   Seleccione opcao: ");
			fflush(stdin); 
			op=getchar();
			if(op=='s' || op== 'S')
			{
				via_pesquisada = pesquisar_via(lv, n); //pesquisa a via
				libertar_via(via_pesquisada); //remove a via pesquisada
				if ((pesquisar_via(lv, n))==NULL) //se já nao existir a via
				{
					printf("\n   *-----------------------------------------------------------*");
					printf("\n   | A via %d foi removida com sucesso!                        |", n);
					printf("\n   *-----------------------------------------------------------*\n\n\n");
//					corrigir_numeracao_vias(lv, n);
				}
				else
				{
					printf("\n   *-----------------------------------------------------------*");
					printf("\n   | ERRO: Nao foi possivel remover a via %d                    |", n);
					printf("\n   *-----------------------------------------------------------*\n\n\n");
				}
			}
		}
}



//********************************************************* MENUS ***********************************************************
char menu_principal() 
{
	char op;
	do{
		system("cls");
		printf("\n #------------------------------------------------------------------#");
		printf("\n | MENU PRINCIPAL                                                   |");
		printf("\n |------------------------------------------------------------------|");
		printf("\n | (1) Criar ou Editar Cenario [+]                                  |");
		printf("\n | (2) Configurar Simulacao                                         |");
		printf("\n | (3) Configurar estado Simulador [+]                              |");
		printf("\n | (4) Consultar Historico                                          |");
		printf("\n | (5) Limpar Historico                                             |");
		printf("\n |                                                                  |");
		printf("\n | (0) SAIR                                                         |");
		printf("\n #------------------------------------------------------------------#\n");
		fflush(stdin);
		printf("\n Seleccione opcao: ");
		fflush(stdin);
		op=getchar();
	} while (op<'0' || op>'5');
	return op;
}

char menu_editar_cenario()
{
	char op;
	do{
		system("cls");
		printf("\n #------------------------------------------------------------------#");
		printf("\n | MENU PRINCIPAL                                                   |");
		printf("\n |------------------------------------------------------------------|");
		printf("\n | (1) CRIAR OU EDITAR CENARIO [-]                                  |");
		printf("\n | (2) Configurar Simulacao          #--------------------------------------#");
		printf("\n | (3) Configurar estado Simulador   | (1) Inserir via                      |");
		printf("\n | (4) Consultar historico           | (2) Editar via                       |");
		printf("\n | (5) Limpar historico              | (3) Eliminar via                     |");
		printf("\n |                                   | (4) Eliminar todas as vias           |");
		printf("\n | (0) SAIR                          |                                      |");
		printf("\n #-----------------------------------| (0) VOLTAR AO MENU PRINCIPAL         |");
		printf("\n                                     #--------------------------------------#");

		/*
		printf("\n #------------------------------------------------------------------#");
		printf("\n | CRIAR OU EDITAR CENARIO                                          |");
		printf("\n |------------------------------------------------------------------|");
		printf("\n | (1) Adicionar nova via                                           |");
		printf("\n | (2) Editar via                                                   |");
		printf("\n | (3) Eliminar via                                                 |");
		printf("\n | (4) Eliminar todas as vias                                       |");
		printf("\n |                                                                  |");
		printf("\n |                                                                  |");
		printf("\n | (0) VOLTAR MENU PRINCIPAL                                        |");
		printf("\n #------------------------------------------------------------------#\n");
		*/
		fflush(stdin);
		printf("\n Seleccione opcao: ");
		fflush(stdin);
		op=getchar();
	} while (op<'0' || op>'4');
	return op;
}


char menu_editar_simulacao(ESTADO *e, int n)
{
	int op, op_tmp;
	do{
		system("cls");
		printf("\n #------------------------------------------------------------------#");
		printf("\n | MENU PRINCIPAL                                                   |");
		printf("\n |------------------------------------------------------------------|");
		printf("\n | (1) Criar ou Editar Cenario [+]                                  |");
		printf("\n | (2) Configurar Simulacao          #-----------------------------------#");
		printf("\n | (3) Configurar estado Simulador   | (1) Iniciar                       |");
		printf("\n | (4) Consultar historico           | (2) Pausar                        |");
		printf("\n | (5) Limpar historico              | (3) Desligar                      |");
		printf("\n |                                   | (0) VOLTAR AO MENU PRINCIPAL      |");
		printf("\n | (0) SAIR                          |                                   |");
		printf("\n #-----------------------------------|                                   |");
		ler_config(e,n);
		mostrar_estado(e);
		printf("\n                                     #-----------------------------------#");
		/*
		printf("\n #------------------------------------------------------------------#");
		printf("\n | CONFIGURAR ESTADO DO SIMULADOR                                   |");
		printf("\n |------------------------------------------------------------------|");
		printf("\n | (1) Iniciar                                                      |");
		printf("\n | (2) Pausar                                                       |");
		printf("\n | (3) Desligar                                                     |");
		printf("\n | (0) VOLTAR MENU PRINCIPAL                                        |");
		printf("\n |                                                                  |");
		printf("\n |                                                                  |");
		printf("\n |                                                                  |");
		ler_config(e, n);
		mostrar_estado(e);
		printf("\n #------------------------------------------------------------------#\n");
		*/
		fflush(stdin);
		printf("\n Seleccione estado: ");
		fflush(stdin);
		scanf("%d",&op);
		//scanf("%d",&e->est);
		//op = e->est;
    }while (op<0 || op>3);
	if(op==0)
		return op;
	else
		e->est = op;
		gravar_config(e, n);
}


// ********************************************** MAIN ***************************************************
void main() 
{
	int num_estado=1, n_via_edit, n_via_rem;
	char op;
	LISTA_VIAS LV;
	VIA via_remover, via_removida, via_pesquisar, via_nova, v;
	ESTADO *estado;
	estado=alocar_memoria(num_estado);
	LV = criar_lista_vias();
//	ler_cenario(LV); // abre o ficheiro cenario.ini
	for(;;)
	{
		system("cls");
		switch (menu_principal()) 
		{
		case '1':
			switch (menu_editar_cenario()) 
			{
				
			case '1':
				//ler_cenario(LV);
				do{
					
					system("cls");
					printf("\n INSERIR NOVA VIA");
					printf("\n--------------------------------------------------------------------");
					via_nova = criar_via();
					ler_via(LV, via_nova);
					inserir_via_lista(LV, via_nova);
					printf("\n  *-----------------------------------------------------------*");
					printf("\n  | Pretende adicionar outra via? (S/N)                       |");
					printf("\n  *-----------------------------------------------------------*");
					printf("\n  Seleccione opcao: ");
					op=getchar();
				}while (op=='S' || op=='s'); 
				gravar_cenario(LV);
				break;

			case '2':
				ler_cenario(LV);
				system("cls");
				printf("\n EDITAR VIA");
				printf("\n-----------------------------------------------------------------------------");
				if(LV->primeira==NULL)
				{
					printf("\n\n   *----------------------------------------------------------------*");
					printf("\n   |                    OPCAO INACTIVA                              |");
					printf("\n   | Ainda nao foram introduzidas vias para poder editar. Adicione  |");
					printf("\n   | nova via usando a opcao 1 no menu Criar/Editar cenario.        |");
					printf("\n   *----------------------------------------------------------------*\n\n\n");
				}
				else{
					printf("\n Editar via numero: ");
					fflush(stdin);
					scanf("%d",&n_via_edit);
					if(n_via_edit>LV->n_vias || n_via_edit<=0) {
						printf("\n   *-----------------------------------------------------------*");
						printf("\n   | ERRO: A via que tentou pesquisar nao existe.              |");
						printf("\n   *-----------------------------------------------------------*\n\n\n");
					}else{
						via_pesquisar = pesquisar_via(LV, n_via_edit);
						editar_via(LV, via_pesquisar); //função que edita a via
					}
				}
				break;

			case '3':
				ler_cenario(LV);
				system("cls");
				printf("\n REMOVER VIA");
				printf("\n----------------------------------------------------------------------------");
				if(LV->primeira==NULL)
				{
					printf("\n\n   *------------------------------------------------------------------*");
					printf("\n   |                        OPCAO INACTIVA                            |");
					printf("\n   | Ainda nao foram introduzidas vias para poder eliminar.           |");
					printf("\n   | Adicione nova via usando a opcao 1 no menu Criar/Editar cenario. |");
					printf("\n   *------------------------------------------------------------------*\n\n\n");
				}
				else{
				printf("\n Remover a via: ");
				fflush(stdin);
				scanf("%d",&n_via_rem);
				if(n_via_rem>LV->n_vias || n_via_rem<=0)
				{
					printf("\n   *-----------------------------------------------------------*");
					printf("\n   | ERRO: A via que tentou eliminar nao existe.               |");
					printf("\n   *-----------------------------------------------------------*\n\n\n");
				}
				else{
					printf("\n   *-----------------------------------------------------------*");
					printf("\n   | Ira perder toda a informacao da via e a numeracao das     |");
					printf("\n   | vias sera corrigida. Pretende continuar?(S/N)             |");
					printf("\n   *-----------------------------------------------------------*");
					printf("\n   Seleccione opcao: ");
					fflush(stdin); 
					op=getchar();
					if(op=='s' || op== 'S')
					{
						via_remover = pesquisar_via(LV, n_via_rem);
						remover_via(LV, via_remover); //função que remove a via
						if(remover_via(LV, via_remover))
						{
							printf("\n   *-----------------------------------------------------------*");
							printf("\n   | Via removida com sucesso!                                 |");
							printf("\n   *-----------------------------------------------------------*\n\n\n");
							gravar_cenario(LV);
						}
						else
						{
							printf("\n   *-----------------------------------------------------------*");
							printf("\n   | ERRO: Nao foi possivel eliminar a via.                    |");
							printf("\n   *-----------------------------------------------------------*\n\n\n");
						}
					}
				}
				break;
				}
				break;

			case '4':
				ler_cenario(LV);
				system("cls");
				printf("\n ELIMINAR TODAS AS VIAS");
				printf("\n----------------------------------------------------------------------------\n");
				printf("\n   *-----------------------------------------------------------*");
				printf("\n   | Esta prestes a apagar todas as vias. Nao podera voltar a  |"); 
				printf("\n   | recuperar quaisquer informacoes das vias.                 |");
				printf("\n   | Pretende continuar?(S/N)                                  |");
				printf("\n   *-----------------------------------------------------------*");
				printf("\n   Seleccione opcao: ");
				fflush(stdin); 
				op=getchar();
				if(op=='s' || op== 'S')
					destruir_lista_vias(LV); //NOTA: se a lista foi bem eliminada, o ficheiro cenario.ini é limpo. Ver funçao destruir.
				break;
			}
			break;

		case '3':
			menu_editar_simulacao(estado, num_estado);
			break;

/*

		case '4':
			if (lista->nelementos == 0)
				printf("Nao existem elementos na lista!\n");
			else
				mostrar_inversa(lista);
			break;
*/
		case '5':
			apagar_historico();
			break;
		
		case '0':
			exit(0);
		}
		system("pause");
	}
}

[quitZAUMMM 18]

Antes de qlqr coisa me diga:

se você mudar isso:

FILE *fich = fopen("C:/Users/Julio/Documents/Visual Studio 2010/Projects/codigo/codigo/cenario.ini", "a");

por isso:

FILE *fich = fopen("C://Users//Julio//Documents//Visual Studio 2010//Projects//codigo//codigo//cenario.ini", "a");

o erro persiste?

 

[]s