C Problema com leitura de arquivos binários

LuisGCarv · 24 de março de 2018

A parte do meu código onde eu gravo informações no arquivo binário aparentemente está correta, porque todos os arquivos são criados normalmente e eu consigo adicionar informações a eles e o tamanho é aumentado quase que simultaneamente. Estou com problemas para passar os dados desses arquivos para as variáveis e apresentar na tela, alguém poderia me ajudar a descobrir o que estou fazendo de errado? Na hora que vai mostrar a lista de dados na tela, o programa simplesmente trava.

int orcamento(void)
{
struct movimentacao *OrcamentoObra;
struct cadastro2 *CadastroImovel;
struct cadastro1 *CadastroColab;

int i = -1, j, k, l, m = -1, n = -1, o = -1, aloc = 0, fim, opcao7, opcao8, loop5;
FILE *ponteiro;

do 
{
printf ("Digite o número da sua opção desejada\nEX: 2\n");
printf ("\n");
printf ("1) Realizar o orçamento de uma obra \n");
printf ("2) Voltar ao menu anterior \n");
printf ("3) Encerrar o processo \n");
scanf ("%d",&opcao7);
system ("cls");
switch(opcao7)
{
case 1:
	i++;
	aloc++;	
	OrcamentoObra = (movimentacao*) malloc(aloc * sizeof(movimentacao));		
	if (!OrcamentoObra) 
	{
        printf("O orçamento infelizmente não poderá ser realizado!\n");
        exit(1);
    }
    else
    {
	do
	{		
    printf ("Digite o tipo de imóvel que será realizado o orçamento");
	printf ("\nEX: 3\n");
	printf ("1) Comercial\n");
	printf ("2) Construção Civil\n");
	printf ("3) Residencial \n");
	scanf ("%d",&opcao8);
	system ("cls");
	if (opcao8 == 1) 
	{	
		strcpy (OrcamentoObra[i].tipo,"Comercial");
		ponteiro = fopen("Cadastrocomercial.dat", "rb");	
		if (ponteiro == NULL)
		{
			printf ("Nenhum cadastro de imóvel comercial realizado, tente novamente!\n");
			system ("pause");
			exit (1);	
		}	
			printf ("Imóveis Comerciais");
			j = 0;	
			while (!feof(ponteiro))
			{
				fread(&CadastroImovel,sizeof(struct cadastro2), 1, ponteiro);	
				printf ("\nCódigo = %d\nProprietário = %s\n", CadastroImovel[j].codigo, CadastroImovel[j].proprietario);
				j++;	
			}
			printf ("\nDigite o código do imóvel que será realizado o orçamento\n");
			scanf ("%d",&OrcamentoObra[i].codigoi);
			system ("cls");
	}
	else
	{
		if (opcao8 == 2)
		{
			strcpy (OrcamentoObra[i].tipo,"Construção Civil");
			ponteiro = fopen("Cadastroconstrucaocivil.dat", "rb");
			if (ponteiro == NULL)
			{
				printf ("Nenhum cadastro de imóvel de construção civil realizado, tente novamente!\n");
				system ("pause");
				exit (1);	
			}			
			printf ("Imóveis de Construção Civil");
			k = 0;	
			while (!feof(ponteiro))
			{
				fread(&CadastroImovel,sizeof(struct cadastro2), 1, ponteiro);
				printf ("\nCódigo = %d\nProprietário = %s\n", CadastroImovel[k].codigo, CadastroImovel[k].proprietario);
				k++;	
			}
			printf ("\nDigite o código do imóvel que será realizado o orçamento\n");
			scanf ("%d",&OrcamentoObra[i].codigoi);
			system ("cls");
		}
		else
		{	
			if (opcao8 == 3)
			{
				strcpy (OrcamentoObra[i].tipo,"Residencial");
				ponteiro = fopen("Cadastroresidencial.dat", "rb");
				if (ponteiro == NULL)
				{
					printf ("Nenhum cadastro de imóvel residencial realizado, tente novamente!\n");
					system ("pause");
					exit (1);	
				}			
				printf ("Imóveis Residenciais");
				l = 0;	
				while (!feof(ponteiro))
				{
					fread(&CadastroImovel,sizeof(struct cadastro2), 1, ponteiro);
					printf ("\nCódigo = %d\nProprietário = %s\n", CadastroImovel[l].codigo, CadastroImovel[l].proprietario);
					l++;	
				}
				printf ("\nDigite o código do imóvel que será realizado o orçamento\n");
				scanf ("%d",&OrcamentoObra[i].codigoi);
				system ("cls");
			}
	else
	{		
			printf ("Opção inválida!\nTente novamente\n");
			system ("pause");
			system ("cls");
			loop5 = 1;		
	}	
}
}
	}while(loop5!=0);
}
free (CadastroImovel);		
fclose (ponteiro); 
ponteiro = fopen("Cadastroarquiteto.dat", "rb");
if (ponteiro == NULL)
{
printf ("Nenhum cadastro de arquiteto realizado, tente novamente!\n");
system ("pause");
exit (1);	
}	
fread(&CadastroColab,sizeof(struct cadastro1), 1, ponteiro);
m++;
OrcamentoObra[i].codigoc1 = CadastroColab[m].codigo;
strcpy (OrcamentoObra[i].nome1 , CadastroColab[m].nome);
free (CadastroColab);	
ponteiro = fopen("Cadastroengenheiro.dat", "rb");
if (ponteiro == NULL)
{
	printf ("Nenhum cadastro de engenheiro realizado, tente novamente!\n");
	system ("pause");
	exit (1);	
}	
fread(&CadastroColab,sizeof(struct cadastro1), 1, ponteiro);
n++;
OrcamentoObra[i].codigoc2 = CadastroColab[n].codigo;
strcpy (OrcamentoObra[i].nome2 , CadastroColab[n].nome);
free (CadastroColab);	
ponteiro = fopen("Cadastropedreiro.dat", "rb");
if (ponteiro == NULL)
{
	printf ("Nenhum cadastro de pedreiro realizado, tente novamente!\n");
	system ("pause");
	exit (1);	
}	
fread(&CadastroColab,sizeof(struct cadastro1), 1, ponteiro);
o++;
OrcamentoObra[i].codigoc3 = CadastroColab[o].codigo;
strcpy (OrcamentoObra[i].nome3 , CadastroColab[o].nome);		
system ("pause");
system ("cls");
printf ("DADOS DO ORÇAMENTO DA OBRA\n");
printf ("\nTipo de imóvel = %s", OrcamentoObra[i].tipo);
printf ("\nCódigo do imóvel = %d", OrcamentoObra[i].codigoi);
printf ("\n\nNome do arquiteto = %s", OrcamentoObra[i].nome1);
printf ("\nCódigo do arquiteto = %d", OrcamentoObra[i].codigoc1);
printf ("\nNome do engenheiro = %s", OrcamentoObra[i].nome2);
printf ("\nCódigo do engenheiro = %d", OrcamentoObra[i].codigoc2);
printf ("\nNome do pedreiro = %s", OrcamentoObra[i].nome3);
printf ("\nCódigo do pedreiro = %d", OrcamentoObra[i].codigoc3);
if (OrcamentoObra[i].tipo == "Residencial")
{
printf ("\nValor total dos gastos = 30.000,00\n");
}
else
{
	if (OrcamentoObra[i].tipo == "Comercial")
	{
	printf ("\nValor total dos gastos = 60.000,00\n");	
	}
	else
	{
		if (OrcamentoObra[i].tipo == "Construção civil")
		{
		printf ("\nValor total dos gastos = 90.000,00\n");	
		}
	}	
}
free (OrcamentoObra);  
break;
case 2:
	fim = 1;
break;
case 3:
	fim = 2;
break;	
default:
	printf ("Opção inválida!\nTente novamente\n");
	system ("pause");
	system ("cls");
}					
}while(opcao7!=2 && opcao7!=3);	
return fim;	
}

Resolvi postar apenas a função onde eu faço a leitura, ai se vocês não encontrarem nada para arrumar, eu posto as outras partes do código.

Agradeço desde já pela atenção

LuisGCarv · 24 de março de 2018

O código buga nessa parte e todas as partes onde essa sequência de comandos é repetida.

strcpy (OrcamentoObra[i].tipo,"Comercial");
		ponteiro = fopen("Cadastrocomercial.dat", "rb");	
		if (ponteiro == NULL)
		{
			printf ("Nenhum cadastro de imóvel comercial realizado, tente novamente!\n");
			system ("pause");
			exit (1);	
		}	
			printf ("Imóveis Comerciais");
			j = 0;	
			while (!feof(ponteiro))
			{
				fread(&CadastroImovel,sizeof(struct cadastro2), 1, ponteiro);	
				printf ("\nCódigo = %d\nProprietário = %s\n", CadastroImovel[j].codigo, CadastroImovel[j].proprietario);
				j++;	
			}
			printf ("\nDigite o código do imóvel que será realizado o orçamento\n");
			scanf ("%d",&OrcamentoObra[i].codigoi);
			system ("cls");
	}

Esse laço de repetição pra leitura está certo? Por favor, me ajudem!

Ansi C · 24 de março de 2018

Olá.. !

Meu palpite é que esse objeto está incorretamente lendo à memória. O que me leva a pensar assim é isto;

aloc++;	
OrcamentoObra = (movimentacao*) malloc(aloc * sizeof(movimentacao));

Pela intenção o Orçamento Obra é ponteiro que aponta para lugares cada vez diferentes e a cada interação. Cada vez que chamas malloc uma lista de locais novos lhe é atribuído, porém você pensa ainda ter o controle dos antigos dados, quando na verdade não tem.

Dica: é use realloc pesquise mais como ela funciona. Credito que essa seja a função que você quer nesse caso.

Com lista em c você melhora seu projeto, se resolver aprender a usar lista vai ter dado um salto em tanto em relação a usar realloc.

~~ / ~~

cyer · 24 de março de 2018

@LuisGCarv siga a dica que foi dada pelo @Mauro Britivaldo, se mesmo assim não funcionar, poste o código todo(ou pelo menos o suficiente para que ele possa ser compilado), é meio difícil dizer onde está o erro sem poder testar o código.

LuisGCarv · 24 de março de 2018

Agora tá dando bug na hora de gravar os dados também. É que eu gostaria de alocar memória em lugar diferente toda vez que eu faço uma interação, mas eu só queria manter enquanto o programa estiver ligado, porque todos os dados coletados serão gravados em arquivos binários. Os arquivos estão sendo gravados normalmente, o programa só estava travando na parte onde eu tento ler o que está escrito nos arquivos, então eu acredito que eu tenha feito algo errado no laço de repetição pra leitura do arquivo, mas eu não tenho ideia do que pode ter sido.

Pra ler todo o conteúdo de um arquivo binário você só precisa fazer um while com com a condição !feof(o ponteiro), um fread e o printf?

Ansi C · 24 de março de 2018

@LuisGCarv suas suspeita estão aparentemente corretas. Eu não vi em que momento se alocou memória para o ponteiro CadastroImovel que até então não se sabe para onde está apontando. Os bytes lidos precisão de lugar reservado para serem gravados. Sem falar que no parâmetro temos o ponteiro-do-ponteiro em sua declaração &CadastroImovel isso para agravar ainda mais o que já estava perdido, aparentemente.

while( !feof ( ponteiro )){
  fread( &CadastroImovel, sizeof ( struct cadastro2 ), 1, ponteiro );
  printf( "\nCódigo = %d\nProprietário = %s\n", CadastroImovel[j].codigo, CadastroImovel[j].proprietario );
  j++;
}

Em que local atribuiu memória?

struct movimentacao *OrcamentoObra;
struct cadastro2 *CadastroImovel; // Atribuir memória a esse cara
struct cadastro1 *CadastroColab;

LuisGCarv · 26 de março de 2018

Ah @Mauro Britivaldo , eu consegui resolver parte do problema com essa sua dica, agora não está mais travando exatamente naquela parte, estava faltando atribuir memória pra esse ponteiro CadastroImovel mesmo, só que agora ele lê até uma parte do arquivo e trava no meio. Vou postar o código inteiro dessa vez pra ver se você sabe o que está dando de errado, porque o código não acusa erro algum na hora de compilar, só quando vou executar mesmo. Teve um momento que eu até consegui passar essa fase da leitura dos dados do arquivo sem a travada, mas a leitura dos dados não estava correta, agora ela está correta mas está travando no meio:

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

struct cadastro1
{
int codigo;
char nome[40], cargo[10]; 	
};

struct cadastro2
{
int codigo;
char proprietario[40], tipo[16];	
};

struct movimentacao
{
int codigoc1, codigoc2, codigoc3, codigoi;
char nome1[40], nome2[40], nome3[40], tipo[10];	
};

int opc;

int menu();
int cadastroCol();
int cadastroImo();
int orcamento();


int main (void)
{	
int opcao1, loop1;
setlocale (LC_ALL,"Portuguese");

do{
opcao1 = menu();  
switch(opcao1)
{
case 1:
loop1 = cadastroCol();
break;

case 2:
loop1 = cadastroImo(); 
break;

case 3:
loop1 = orcamento();
break;

case 4:
loop1 = 2;	
break;

default:
printf ("Opção inválida!\nTente novamente\n");
system ("pause");
system ("cls");
break;	
}

}while(loop1 == 1);
system ("pause");
return 0;			
}

int menu(void)
{
int loop2, opcao2;
do
{
		printf ("Digite o número da sua opção desejada\nEX: 1\n\n");
		printf ("1) Cadastro de colaborador \n");
		printf ("2) Cadastro de imóvel \n");
		printf ("3) Orçamento de obra \n");
		printf ("4) Encerrar o processo\n");
		scanf ("%d",&opcao2);
		loop2 = 0;
		system ("cls");
		if (opcao2 < 1 || opcao2 > 4)
		{
			printf ("Opção inválida!\nTente novamente\n");
			system ("pause");
			system ("cls");
		    loop2 = 1;	
		}	
}while(loop2!=0);
return opcao2;	
}


int cadastroCol(void)
{
struct cadastro1 *CadastroColab;
int a = -1, b = 1001, c = 2001, d = 3001, aloc = 0, fim, opcao3, opcao4, loop3;
FILE *ponteiro;

do 
{ 
printf ("Digite o número da sua opção desejada\nEX: 2\n\n");
printf ("1) Cadastrar um colaborador \n");
printf ("2) Voltar ao menu anterior \n");
printf ("3) Encerrar o processo \n");
scanf ("%d",&opcao3);
system ("cls");
switch(opcao3)
{
case 1:
    a++;	
	aloc++;
	CadastroColab = (cadastro1*) calloc(aloc, sizeof(cadastro1));
		
	if (!CadastroColab) 
	{
        printf("O cadastro infelizmente não poderá ser realizado!\n");
        exit(1);
    }
    else
    {	
    printf ("Digite o nome do colaborador : \n");
    getchar ();
	scanf ("%[^\n]s",&CadastroColab[a].nome);
do
{	
	printf ("\nDigite o número com a área do colaborador\nEX: 3\n\n");
	printf ("1) Arquiteto\n");
	printf ("2) Engenheiro \n");
	printf ("3) Pedreiro \n");
	scanf ("%d",&opcao4);
	system ("cls");
if (opcao4 == 1) 
{	
strcpy (CadastroColab[a].cargo,"Arquiteto");
CadastroColab[a].codigo = b;
ponteiro = fopen("Cadastroarquiteto.dat", "ab");	
fwrite(&CadastroColab[a],sizeof(struct cadastro1), 1, ponteiro);
b++;
loop3 = 0;
} 
else
{
	if (opcao4 == 2)
	{	
	strcpy (CadastroColab[a].cargo,"Engenheiro");
    CadastroColab[a].codigo = c;
    ponteiro = fopen("Cadastroengenheiro.dat", "ab");		
	fwrite(&CadastroColab[a],sizeof(struct cadastro1), 1, ponteiro);
	c++;
	loop3 = 0;	
	}
	else
	{
		if (opcao4 == 3)
		{
		strcpy (CadastroColab[a].cargo,"Pedreiro");	
		CadastroColab[a].codigo = d;
		ponteiro = fopen("Cadastropedreiro.dat", "ab");	
		fwrite(&CadastroColab[a],sizeof(struct cadastro1), 1, ponteiro);
		d++;
		loop3 = 0;
		}
		else
		{
		printf ("Opção inválida!\nTente novamente\n");
		system ("pause");
		system ("cls");
		loop3 = 1;		
		}	
	}
}
}while(loop3!=0);
	} 
free (CadastroColab);   	
fclose (ponteiro);  

break;
case 2:
	fim = 1;
break;
case 3:
	fim = 2;
break;	
default:
	printf ("Opção inválida!\nTente novamente\n");
	system ("pause");
	system ("cls");	
}
}while(opcao3!=2 && opcao3!=3);

return fim;
}


int cadastroImo(void)
{
struct cadastro2 *CadastroImovel;
int e = -1, f = 4001, g = 5001, h = 6001, fim, opcao5, opcao6, loop4, aloc = 0;
FILE *ponteiro;

do 
{
printf ("Digite o número da sua opção desejada\nEX: 2\n\n");
printf ("1) Cadastrar um imóvel \n");
printf ("2) Voltar ao menu anterior \n");
printf ("3) Encerrar o processo \n");
scanf ("%d",&opcao5);
system ("cls");
switch(opcao5)
{
case 1:	
	e++;
	aloc++;
	CadastroImovel = (cadastro2*) calloc(aloc, sizeof(cadastro2));		
	if (!CadastroImovel) 
	{
        printf("O cadastro infelizmente não poderá ser realizado!\n");
        exit(1);
    }
    else
    {		
    printf ("Digite o nome do proprietário do imóvel a ser construído: \n");
    getchar ();
	scanf ("%[^\n]s",&CadastroImovel[e].proprietario);	
	do
	{
	printf ("\nDigite o número com o tipo de imóvel a ser construído: \nEX: 3\n\n");
	printf ("1) Comercial\n");
	printf ("2) Construção Civil\n");
	printf ("3) Residencial \n");
	scanf ("%d",&opcao6);
	system ("cls");
if (opcao6 == 1) 
{
strcpy (CadastroImovel[e].tipo,"Comercial");
CadastroImovel[e].codigo = f;
ponteiro = fopen("Cadastrocomercial.dat", "ab");	
fwrite(&CadastroImovel[e],sizeof(struct cadastro2), 1, ponteiro);
f++;
loop4 = 0;
} 
else
{
	if (opcao6 == 2)
	{
	strcpy (CadastroImovel[e].tipo,"Construção Civil");
    CadastroImovel[e].codigo = g;
    ponteiro = fopen("Cadastroconstrucaocivil.dat", "ab");	
	fwrite(&CadastroImovel[e],sizeof(struct cadastro2), 1, ponteiro);
	g++;
	loop4 = 0;	
	}
	else
	{
		if (opcao6 == 3)
		{
		strcpy (CadastroImovel[e].tipo,"Residencial");	
		CadastroImovel[e].codigo = h;
		ponteiro = fopen("Cadastroresidencial.dat", "ab");	
		fwrite(&CadastroImovel[e],sizeof(struct cadastro2), 1, ponteiro);
		h++;
		loop4 = 0;
		}
		else
		{
		printf ("Opção inválida!\nTente novamente\n");
		system ("pause");
		system ("cls");
		loop4 = 1;		
		}	
	}
}
}while(loop4!=0);
}	
	
free (CadastroImovel);	
fclose (ponteiro);     
break;
case 2:
	fim = 1;
break;
case 3:
	fim = 2;
break;	
default:
	printf ("Opção inválida!\nTente novamente\n");
	system ("pause");
	system ("cls");			
}
}while(opcao5!=2 && opcao5!=3);
return fim;
}

int orcamento(void)
{
struct movimentacao *OrcamentoObra;
struct cadastro2 *CadastroImovel;
struct cadastro1 *CadastroColab;

int i = -1, j, k, l, m = -1, n = -1, o = -1, fim, opcao7, opcao8, loop5, aloc = 0;
FILE *ponteiro;

do 
{
printf ("Digite o número da sua opção desejada\nEX: 2\n\n");
printf ("1) Realizar o orçamento de uma obra \n");
printf ("2) Voltar ao menu anterior \n");
printf ("3) Encerrar o processo \n");
scanf ("%d",&opcao7);
system ("cls");
switch(opcao7)
{
case 1:
	i++;
	aloc++;
	OrcamentoObra = (movimentacao*) calloc(aloc, sizeof(movimentacao));	
	CadastroImovel = (cadastro2*) calloc(aloc, sizeof(cadastro2));	
	CadastroColab = (cadastro1*) calloc(aloc, sizeof(cadastro1));	
	if (!OrcamentoObra) 
	{
        printf("O orçamento infelizmente não poderá ser realizado!\n");
        exit(1);
    }
    else
    {
	do
	{		
    printf ("Digite o tipo de imóvel que será realizado o orçamento\nEX: 3\n\n");
	printf ("1) Comercial\n");
	printf ("2) Construção Civil\n");
	printf ("3) Residencial \n");
	scanf ("%d",&opcao8);
	system ("cls");
	if (opcao8 == 1) 
	{	
		strcpy (OrcamentoObra[i].tipo,"Comercial");
		ponteiro = fopen("Cadastrocomercial.dat", "rb");	
		if (ponteiro == NULL)
		{
			printf ("Nenhum cadastro de imóvel comercial realizado, tente novamente!\n");
			system ("pause");
			exit (1);	
		}
		else
		{
				
			printf ("Imóveis Comerciais");
			j = 0;	
			while (!feof(ponteiro))
			{	
				fread(&CadastroImovel[j],sizeof(struct cadastro2), 1, ponteiro);	
				printf ("\nCódigo = %d\nProprietário = %s\n", CadastroImovel[j].codigo, CadastroImovel[j].proprietario);
				j++;		
			}
			printf ("\nDigite o código do imóvel que será realizado o orçamento\n");
			scanf ("%d",&OrcamentoObra[i].codigoi);
			system ("cls");
		}
	}
	else
	{
		if (opcao8 == 2)
		{
			strcpy (OrcamentoObra[i].tipo,"Construção Civil");
			ponteiro = fopen("Cadastroconstrucaocivil.dat", "rb");
			if (ponteiro == NULL)
			{
				printf ("Nenhum cadastro de imóvel de construção civil realizado, tente novamente!\n");
				system ("pause");
				exit (1);	
			}
			else
			{
				printf ("Imóveis de Construção Civil");
				k = 0;	
				while (!feof(ponteiro))
				{
					fread(&CadastroImovel[k],sizeof(struct cadastro2), 1, ponteiro);
					printf ("\nCódigo = %d\nProprietário = %s\n", CadastroImovel[k].codigo, CadastroImovel[k].proprietario);
					k++;	
				}
				printf ("\nDigite o código do imóvel que será realizado o orçamento\n");
				scanf ("%d",&OrcamentoObra[i].codigoi);
				system ("cls");		
			}			

		}
		else
		{	
			if (opcao8 == 3)
			{
				strcpy (OrcamentoObra[i].tipo,"Residencial");
				ponteiro = fopen("Cadastroresidencial.dat", "rb");
				if (ponteiro == NULL)
				{
					printf ("Nenhum cadastro de imóvel residencial realizado, tente novamente!\n");
					system ("pause");
					exit (1);	
				}
				else
				{
					printf ("Imóveis Residenciais");
					l = 0;	
					while (!feof(ponteiro))
					{
						fread(&CadastroImovel[l],sizeof(struct cadastro2), 1, ponteiro);
						printf ("\nCódigo = %d\nProprietário = %s\n", CadastroImovel[l].codigo, CadastroImovel[l].proprietario);
						l++;	
					}
					printf ("\nDigite o código do imóvel que será realizado o orçamento\n");
					scanf ("%d",&OrcamentoObra[i].codigoi);
					system ("cls");	
				}			

			}
	else
	{		
			printf ("Opção inválida!\nTente novamente\n");
			system ("pause");
			system ("cls");
			loop5 = 1;		
	}	
}
}
	}while(loop5!=0);
}
free (CadastroImovel);		
fclose (ponteiro); 
ponteiro = fopen("Cadastroarquiteto.dat", "rb");
if (ponteiro == NULL)
{
printf ("Nenhum cadastro de arquiteto realizado, tente novamente!\n");
system ("pause");
exit (1);	
}	
fread(&CadastroColab,sizeof(struct cadastro1), 1, ponteiro);
m++;
OrcamentoObra[i].codigoc1 = CadastroColab[m].codigo;
strcpy (OrcamentoObra[i].nome1 , CadastroColab[m].nome);
free (CadastroColab);	
ponteiro = fopen("Cadastroengenheiro.dat", "rb");
if (ponteiro == NULL)
{
	printf ("Nenhum cadastro de engenheiro realizado, tente novamente!\n");
	system ("pause");
	exit (1);	
}	
fread(&CadastroColab,sizeof(struct cadastro1), 1, ponteiro);
n++;
OrcamentoObra[i].codigoc2 = CadastroColab[n].codigo;
strcpy (OrcamentoObra[i].nome2 , CadastroColab[n].nome);
free (CadastroColab);	
ponteiro = fopen("Cadastropedreiro.dat", "rb");
if (ponteiro == NULL)
{
	printf ("Nenhum cadastro de pedreiro realizado, tente novamente!\n");
	system ("pause");
	exit (1);	
}	
fread(&CadastroColab,sizeof(struct cadastro1), 1, ponteiro);
o++;
OrcamentoObra[i].codigoc3 = CadastroColab[o].codigo;
strcpy (OrcamentoObra[i].nome3 , CadastroColab[o].nome);		
system ("pause");
system ("cls");
printf ("DADOS DO ORÇAMENTO DA OBRA\n");
printf ("\nTipo de imóvel = %s", OrcamentoObra[i].tipo);
printf ("\nCódigo do imóvel = %d", OrcamentoObra[i].codigoi);
printf ("\n\nNome do arquiteto = %s", OrcamentoObra[i].nome1);
printf ("\nCódigo do arquiteto = %d", OrcamentoObra[i].codigoc1);
printf ("\nNome do engenheiro = %s", OrcamentoObra[i].nome2);
printf ("\nCódigo do engenheiro = %d", OrcamentoObra[i].codigoc2);
printf ("\nNome do pedreiro = %s", OrcamentoObra[i].nome3);
printf ("\nCódigo do pedreiro = %d", OrcamentoObra[i].codigoc3);
if (OrcamentoObra[i].tipo == "Residencial")
{
printf ("\nValor total dos gastos = 30.000,00\n");
}
else
{
	if (OrcamentoObra[i].tipo == "Comercial")
	{
	printf ("\nValor total dos gastos = 60.000,00\n");	
	}
	else
	{
		if (OrcamentoObra[i].tipo == "Construção civil")
		{
		printf ("\nValor total dos gastos = 90.000,00\n");	
		}
	}	
}
free (OrcamentoObra);  
break;
case 2:
	fim = 1;
break;
case 3:
	fim = 2;
break;	
default:
	printf ("Opção inválida!\nTente novamente\n");
	system ("pause");
	system ("cls");
}					
}while(opcao7!=2 && opcao7!=3);	
return fim;	
}

adicionado 34 minutos depois

Queria também poder enxugar esse código ao máximo sem perder as operações dele, mas por enquanto a prioridade é fazê-lo não dar erro.

Ansi C · 27 de março de 2018

6 horas atrás, LuisGCarv disse:

Queria também poder enxugar esse código ao máximo sem perder as operações dele, mas por enquanto a prioridade é fazê-lo não dar erro.

Não fiz nada sua lógica, modifiquei apenas alguns coisa da memória, sintaxe e a algoritmos 90% preservados. Não testei porque não tenho banco de dados de teste, depois poste a versão de teste caso ainda tenha erros que podemos ajudar. Notei que as operações são interdependente isso é ruim, faça uma função somente para leitura de Orçamento que por enquanto não funciona direito.

Code.c

LuisGCarv · 27 de março de 2018

Ah, muito obrigado! As suas alterações fizeram com que o programa lesse todo o arquivo sem travar. Eu não conhecia esse comando da flecha ->, como ele funciona exatamente?

Ansi C · 27 de março de 2018

10 horas atrás, LuisGCarv disse:

como ele funciona exatamente?

É uma atalho que está presente desda primeira versão do C para referencias de struct. A ideia é evitar trechos longos de referencias por meio de uma sintaxe que seja melhor intuitiva.

Exemplo:

struct *y = calloc( 1, struct );
//Isto aqui       
  y->string;           

//É igual a isso aqui
  (*y).string;

//Também aqui, porém aqui envolve 1 procedimento extra
  0[y].string;/* ou */ y[0].string;

Se vetores de struct, temos:

struct *y = calloc( 3, struct );
//Isto aqui       
  (2 + y)->string;           

//É igual a isso aqui
  (*(2 + y)).string;

//Também aqui, porém aqui envolve 1 procedimento extra
  2[y].string;/* ou */ y[2].string;

• Quanto se trada de ponteiro para estrutura uso a notação 1º.

• Quando se trada de Ponteiros, Vetores e Matrizes, para outros tipos, uso a notação 3ª caso 1. Porque é menos comum

~~ / ~~