Falha de Segmentação [RESOLVIDO]

1. Falha de Segmentação [RESOLVIDO]

v8yuricoelho
(usa Ubuntu)

Enviado em 05/03/2017 - 16:40h

Olá a todos, necessito fazer o seguinte programa:

Seja uma estrutura para descrever os carros de uma determinada revendedora, contendo os
seguintes campos:
marca: string de tamanho dinâmico
ano: inteiro
cor: string de tamanho dinâmico
preço: real
a) Escrever a definição da estrutura carro.
b) Declarar o vetor vetcarros do tipo da estrutura definida acima, de tamanho dinâmico.
Crie um menu para:
c) Definir um bloco de programa para ler o vetor vetcarros.
d) Definir um bloco de programa que receba um preço e imprima os carros (marca, cor e ano) que
tenham preço igual ou menor ao preço recebido.
e) Defina um bloco de programa que leia a marca de um carro e imprima as informações de todos
os carros dessa marca (preço, ano e cor).
f) Defina um bloco de programa que leia uma marca, ano e cor e informe se existe ou não um carro
com essas características. Se existir, informar o preço.

Estou criando e compilando o programa por blocos, e até agora estou no bloco c. Porém, durante a execução do programa, após implementar a primeira entrada, o programa é encerrado com uma "falha de segmentação". Eis o meu código:

// Declarando bibliotecas auxiliares:



#include <stdio.h>

#include <stdlib.h>

#include <string.h>



// Estrutura do carro:



typedef struct

{

	char marca[20];

	char cor[20];

	int ano;

	float price;

} CARROS;



CARROS *vet_carros; // Declarando "vet_carros" como variável global.



// Declarando funções auxiliares:



void alocaVetor (int quant, CARROS *vet_carros);

void lerCarros (int quant, CARROS *vet_carros);



// Início:



int main (void)

{

	int quant; // Variável que irá armazenar o tamanho do vetor.



	printf ("Defina a quantidade de carros a serem lidos: ");

	scanf ("%d", &quant);



	alocaVetor (quant, vet_carros);



	lerCarros (quant, vet_carros);



	return 0;

}



// Função responsável por alocar o vetor de carros:



void alocaVetor (int quant, CARROS *vet_carros)

{

	vet_carros = (CARROS *) malloc (quant * sizeof (CARROS));

	if (vet_carros == NULL)

	{

		printf ("\aERRO DE MEMORIA!!!");

		exit (-1);

	}

}



// Função responsável por solicitar as entradas ao usuário e as ler:



void lerCarros (int quant, CARROS *vet_carros)

{

	printf ("\nEntre com a marca: ");

	setbuf(stdin, NULL);

	fgets (vet_carros -> marca, 20, stdin);



	printf ("Entre com a cor: ");

	setbuf(stdin, NULL);

	fgets (vet_carros -> cor, 20, stdin);



	printf ("Entre com o ano: ");

	scanf ("%d", &vet_carros -> ano);

	

	printf ("Entre com o preco: ");

	scanf ("%f", &vet_carros -> price);

}

0 0

Quote

2. MELHOR RESPOSTA

uilianries
(usa Linux Mint)

Enviado em 05/03/2017 - 19:30h

Observe as funções alocaVetor e lerCarros. Ambas recebem um ponteiro do tipo CARROS, até aí tudo bem.
Agora observe o comportamento ao passar vet_carros para a função alocaVetor, quando o malloc é realizado, a região alocada, é atribuída a vet_carros, logo após, temos a função lerCarros, que recebe um valor da entrada e armazena nesse vetor até aí, tudo parece bem.

Na verdade, o comportamento pode não parecer tão intuitivo, mas a variável vet_carros da linha 44, não é a mesma da linha 17.
Observe a linha 33:

alocaVetor (quant, vet_carros);

Nessa linha, vet_carros foi copiada silenciosamente pelo compilador, para um novo ponteiro temporário.

Agora, observe a linha 44:

vet_carros = (CARROS *) malloc (quant * sizeof (CARROS));

Este vet_carros não é o mesmo global, ele é a própria cópia, possui endereço diferente.
Você pode observar o endereço de cara um, através de:

printf("%p\n", &vet_carros);

Coloque esse trecho nas linhas 32 e 45, observe a diferença.

E como consertar isso?
Lembre que o ponteiro é um tipo de variável que armazena um endereço, logo você pode usar um ponteiro que armazena o endereço de outro ponteiro, o vet_carros neste caso.



void alocaVetor (int quant, CARROS **vet_carros) {

   *vet_carros = malloc(...);

}



int main () {

    alocaVetor(quant, &vet_carros);

    ...

}

Novamente teremos o ponteiro copiado, mas a cópia preserva o conteúdo, logo, conseguir manter o mesmo endereço do vet_carros original, quando é realizado o acesso através do *.

Espero ter ajudado.
--
Uilian Ries
Linux Counter: 521986

2 0

Quote

3. Re: Falha de Segmentação

paulo1205
(usa Ubuntu)

Enviado em 06/03/2017 - 12:42h

A explicação do UilianRies está correta e a sugestão dele funciona. Mesmo assim, eu gostaria de fazer uma sugestão ligeiramente diferente.

Em lugar de passar o endereço do ponteiro como argumento de uma função alocaVetor() que tem tipo de retorno void, use a forma tradicional do C para a obtenção de recursos: passe as informações para a criação do objeto como parâmetros, e faça a função retornar um ponteiro para o objeto criado.

CARROS *alocaVetor(size_t quant){

  return malloc(quant*sizeof(CARROS));

}

Note que a função retorna um ponteiro nulo em caso de erros, refletindo o comportamento da própria malloc(). Também faz parte do modo tradicional de usar o C que funções de biblioteca não abortam o programa por conta própria (exceto funções que servem exatamente para isso, tais como exit(), abort() e assert()), mas sinalizam situações de erro a quem as chamou, a fim de que o chamador decida como proceder.

A forma de chamar essa função seria parecida com a seguinte.

  if(!(vet_carros=alocaVetor(quant))){

    fprintf(stderr, "Erro de alocação de memória: %s.\n", strerror(errno));

    return 1;

  }

Por fim, note que o nome “alocaVetor” possivelmente não é o melhor do mundo, pois ele não deixa claro que se refere a um tipo de vetor específico. Ao programar, você deve ser sempre procurar ser específico. Nomes como alocaVetorCarros ou simplesmente alocaCarros seriam muito mais claros para quem quer que lesse seu programa.

1 0

Quote