C Distância entre dois Pontos com Struct e Função

Liara K · 14 de janeiro de 2021

Olá, boa tarde!

Estou tentando resolver o seguinte exercício:

Implemente uma estrutura que caracterize um ponto (coordenadas x e y). Utilize a estrutura criada para
ler dois pontos e calcular a distância entre eles.

Não consegui compilar, acho que deu problema na atribuição da variável de entrada na variável da estrutura Struct, tentei um jeito de resolver mas o máximo que consegui foi o script a seguir... a quem puder me ajudar o meu muito obrigada de verdade!!

#include <stdio.h>
#include <stdlib.h>
#include <locale.h>
#include <time.h>
#include <math.h>

typedef struct 
{
	float Ponto1;
	float Ponto2;
}PTO;

float dist_ptos(PTO*x, PTO*y)
{
	float dist_ptos = sqrt(pow((x->Ponto2 - x->Ponto1),2) + pow((y->Ponto2 - y->Ponto1),2));
	return dist_ptos;
}

int main()
{
	setlocale(LC_ALL,"Portuguese");
	
	PTO P1[2]; // x, y
	PTO P2[2]; // x, y
	
	int i = 0;
	printf("Digite os pontos x, y do Ponto 1:");
	for (i = 0; i < 2; i++);
	{
		scanf("%f", P1[i]);
	}
	
	printf("Digite os pontos x, y do Ponto 2:");
	for (i = 0; i < 2; i++);
	{
		scanf("%f", P2[i]);
	}

    dist_ptos(&P1, &P2);
    
    printf("A distancia entre os Pontos 1 e 2 é igual a: %f", dist_ptos);

	system("pause");
	return 0;
}

arfneto · 14 de janeiro de 2021

typedef struct 
{
	float Ponto1;
	float Ponto2;

}	PTO;

float dist_ptos(PTO*x, PTO*y)
{
	float dist_ptos = sqrt(pow((x->Ponto2 - x->Ponto1),2) + pow((y->Ponto2 - y->Ponto1),2));
	return dist_ptos;
}

@Liara K na função dist_ptos() o que é x? o que é y? São claro PTO*. Só que ao chamar a função que argumentos você usou? P1 e P2... Que são P1 e P2? são PTO[2]. PTO[2] não serve...

Não é surpresa dar erro. Como não seria surpresa o compilador aceitar

    dist_ptos(&P1[0], &P1[1]);

Outro erro: TESTE o retorno de scanf(). SEMPRE.

Leia os dois valores juntos. É muito chato digitar um depois do outro...

devair1010 · 14 de janeiro de 2021

@Liara K não precisa de dois vetores de struct para armazenar os 4 valores , não , pode ser apenas um mesmo , com 4 posições , e esses cálculos não sei com faze-los não , e seu código poderia ser assim :

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
#include <locale.h>
#include <time.h>
#include <math.h>

typedef struct
{
	float Ponto1;
	float Ponto2;
}PTO;

float dist_ptoss(PTO* x, PTO* y)
{
	float dist_ptos = sqrt(pow((x->Ponto2 - x->Ponto1), 2) + pow((y->Ponto2 - y->Ponto1), 2));
	return dist_ptos;
}

int main()
{
	setlocale(LC_ALL, "Portuguese");

	PTO P1[4]; // x, y
	int i = 0;
	float dist_ptos;
	printf("Digite o pontos x1: ");
	scanf("%f", &P1[0].Ponto1);
	printf("Digite o ponto y1: ");
	scanf("%f", &P1[1].Ponto1);
	printf("Digite o ponto x2: ");
	scanf("%f", &P1[2].Ponto2);
	printf("Digite o ponto y2: ");
	scanf("%f", &P1[3].Ponto2);
	dist_ptos = dist_ptoss(&P1[0], &P1[0]);

	printf("\nA distancia entre os Pontos 1 e 2 é igual a: %.3f\n\n", dist_ptos);

	system("pause");
	printf("\n\n\n");
	return 0;
}

Liara K · 15 de janeiro de 2021

Obrigada pelos ajustes, ainda não está calculando certo, mas pelo menos já está compilando:

#include <stdio.h>
#include <stdlib.h>
#include <locale.h>
#include <time.h>
#include <math.h>

typedef struct PTO
{
    float Ponto1;
    float Ponto2;
}PTO;

float dist_ptos(PTO *x, PTO *y)
{
    float dist_ptos = sqrt( pow((x->Ponto2 - x->Ponto1),2) + pow((y->Ponto2 - y->Ponto1),2));
    return dist_ptos;
}

int main()
{
    setlocale(LC_ALL,"Portuguese");
    
    PTO X;
    PTO Y;
    
    printf("Digite as coordenadas do Pontos 1:");
    scanf("%f %f", &X.Ponto1 , &Y.Ponto1);
    
    printf("Digite as coordenadas do Ponto 2:");
    scanf("%f %f", &X.Ponto2, &Y.Ponto2);

    dist_ptos(&X, &Y);
    
    printf("\n As coordenadas do ponto 1 são: %f %f \n", X.Ponto1, Y.Ponto1);
    printf("\n As coordenadas do ponto 2 são: %f %f \n", X.Ponto2, Y.Ponto2);
    printf("\n A distancia entre os Pontos 1 e 2 é igual a: %f \n", dist_ptos);

    system("pause");
    return 0;
}

devair1010 · 15 de janeiro de 2021

@Liara K esses cálculos são bem muito fifíceis mesmo , ainda não consegui fazer eles não , e creio que precisa de uma variável para coletar o valor retornado lá da função que calcula ou colocar a chamada da função dentro do printf , e seu código ficaria assim :

#include <stdio.h>
#include <windows.h>
#include <stdlib.h>
#include <locale.h>
#include <time.h>
#include <math.h>

typedef struct PTO
{
    float Ponto1;
    float Ponto2;
}PTO;

float dist_ptos(PTO *x, PTO *y)
{
    float dist_ptos = sqrt( pow((x->Ponto2 - x->Ponto1),2) + pow((y->Ponto2 - y->Ponto1),2));
    return dist_ptos;
}
void textcolor(int,int);
int main()
{
    setlocale(LC_ALL,"Portuguese");
    int letra_antes, fundo_antes,cor;
    HANDLE h = GetStdHandle(STD_OUTPUT_HANDLE);
    CONSOLE_SCREEN_BUFFER_INFO c;
    if(GetConsoleScreenBufferInfo(h, &c))
    {
        cor  = ( c.wAttributes & 0xFF);
        letra_antes = ( c.wAttributes & 0xFF) & 0x0F;
        fundo_antes = ((c.wAttributes & 0xFF) >> 4) & 0x0F;
    }
    PTO X;
    PTO Y;
    float resultado;
    textcolor(14,0);
    printf("Digite as coordenadas do Pontos 1:");
    textcolor(11,0);
    scanf("%f %f", &X.Ponto1 , &Y.Ponto1);
    textcolor(14,0);
    printf("Digite as coordenadas do Ponto 2:");
    textcolor(11,0);
    scanf("%f %f", &X.Ponto2, &Y.Ponto2);

    resultado = dist_ptos(&X, &Y);
    textcolor(7,0);
    printf("\n As coordenadas do ponto 1 são: ");
    textcolor(15,12);
    printf("  %f %f  \n", X.Ponto1, Y.Ponto1);
    textcolor(7,0);
    printf("\n As coordenadas do ponto 2 são: ");
    textcolor(15,12);
    printf("  %f %f  \n", X.Ponto2, Y.Ponto2);
    textcolor(12,14);
    printf("\n A distancia entre os Pontos 1 e 2 é igual a: %.2f \n", dist_ptos (&X, &Y) );
    textcolor(10,12);
    printf("\n A distancia entre os Pontos 1 e 2 é igual a: %.2f \n", resultado);
    printf("\n\n\n");
    textcolor(letra_antes,fundo_antes);
    system("pause");
    return 0;
}
void textcolor(int letra,int fundo)
{
    SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE),letra + (fundo<<4));
}

arfneto · 15 de janeiro de 2021

15 horas atrás, arfneto disse:

Outro erro: TESTE o retorno de scanf(). SEMPRE.

leu isso?

TESTE. SEMPRE. É ingênuo seguir sem saber se leu. E mostre os valores antes de calcular. Porque não?

15 horas atrás, devair1010 disse:

printf("\nA distancia entre os Pontos 1 e 2 é igual a: %.3f\n\n", dist_ptos);

8 horas atrás, Liara K disse:

printf("\n A distancia entre os Pontos 1 e 2 é igual a: %f \n", dist_ptos);

@devair1010 @Liara K dist_pos é uma função. Não podem escrever isso no printf()

float dist_ptos(PTO *x, PTO *y)
{
    float dist_ptos = sqrt( pow((x->Ponto2 - x->Ponto1),2) + pow((y->Ponto2 - y->Ponto1),2));
    return dist_ptos;
}

Porque dentre tantos possíveis nomes declarou uma variável de que não precisava e com o MESMO nome da função? Quer testar o compilador? Ou apenas confundir quem está lendo? Não faça isso. Use o simples.

E a fórmula está errada. E os nomes não estão NADA bons. Entenda:

typedef struct PTO
{
    float Ponto1;
    float Ponto2;
}PTO;

PTO é um ponto. Tem duas coordenadas. Linha e coluna. Só arruma confusão declarando Ponto1 e Ponto2 porque não são pontos. São coordenadas no plano cartesiano, linha e coluna. Em geral a coluna é x e a linha é y... E aí você vai na função e usa c e y como PTO? Mais confusão. Compare com o simples

typedef struct
{
	float linha;
	float coluna;

}	Ponto;

E a fórmula está errada. Se tivesse escrito em torno dos dados e com nomes mais significativos não teria errado. E não precisa de pow(x,2) para x * x afinal...

Veja o simples:

Trata-se do teorema de Pitágoras, certo?

Para calcular o comprimento AB que é a hipotenusa do triângulo. Agora volta acima e veja a fórmula que escreveu...

Use nomes mais significativos. E entenda que na matemática x é a coluna e não a linha. Mas em geral na hora de digitar se escreve linha e depois coluna então

NÃO alimente essa ambiguidade...

Veja uma opção mais clara:

float dist_ptos(Ponto* A, Ponto* B)
{
	return (float) sqrt(
		(A->linha - B->linha) * (A->linha - B->linha) +
		(A->coluna - B->coluna) * (A->coluna - B->coluna)
	);
}

Acho que entende a diferença.

Um exemplo que mostra

Digite linha e coluna do Ponto [separados por ao menos um espaco]: 2 4
Digite linha e coluna do Ponto [separados por ao menos um espaco]: 5 8

Distancia entre (2.00, 4.00) e (5.00, 8.00) = 5.00000

Tecle ENTER para encerrar...

#include <stdio.h>
#include <math.h>

typedef struct
{
	float linha;
	float coluna;

}	Ponto;

float dist_ptos(Ponto* A, Ponto* B)
{
	return (float)sqrt(
		(A->linha - B->linha) * (A->linha - B->linha) +
		(A->coluna - B->coluna) * (A->coluna - B->coluna)
	);
}

int 		ler_ponto(Ponto* P)
{
	printf("Digite linha e coluna do Ponto [separados por ao menos um espaco]: ");
	int res = scanf("%f %f", &P->linha, &P->coluna);
	if (res != 2) return 0;
	return 1;
};

int main(void)
{

	Ponto A;
	Ponto B;
	int res = ler_ponto(&A);
	if (res == 0)
	{
		printf("Nao conseguiu ler as coordenadas de A :(\n");
		return -1;
	};

	res = ler_ponto(&B);
	if (res == 0)
	{
		printf("Nao conseguiu ler as coordenadas de B :(\n");
		return -1;
	};

	printf("\nDistancia entre (%.2f, %.2f) e (%.2f, %.2f) = %.5f\n",
		A.linha, A.coluna,
		B.linha, B.coluna,
		dist_ptos(&A, &B)
	);

	printf("\nTecle ENTER para encerrar... \n");
	fgetc(stdin);
	return 0;
}

devair1010 · 15 de janeiro de 2021

@arfneto o código está funcionando bem e faz o cálculo certo , e você colocou o fgetc no final para esperar um pouco para visualizar o resultado ? , mas aqui não deu assim não , ele passa direto para o final .

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <math.h>

typedef struct
{
    float linha;
    float coluna;
}	Ponto;

float dist_ptos(Ponto* A, Ponto* B)
{
    return (float)sqrt
    (
        (A->linha - B->linha) * (A->linha - B->linha) +
        (A->coluna - B->coluna) * (A->coluna - B->coluna)
    );
}

int 		ler_ponto(Ponto* P)
{
    printf("Digite linha e coluna do Ponto [separados por ao menos um espaco]: ");
    int res = scanf("%f %f", &P->linha, &P->coluna);
    if (res != 2) return 0;
    return 1;
};

int main(void)
{

    Ponto A;
    Ponto B;
    int res;
    char c;
    do
    {
        res = ler_ponto(&A);
        if (res == 0)
        {
            printf("Nao conseguiu ler as coordenadas de A :(\n");
        };
    } while ( ! res );

    res = ler_ponto(&B);
    do
    {
        if (res == 0)
        {
            printf("Nao conseguiu ler as coordenadas de B :(\n");
        };
    } while ( ! res );

    printf
    (    "\nDistancia entre (%.2f, %.2f) e (%.2f, %.2f) = %.5f\n",
         A.linha, A.coluna,
         B.linha, B.coluna,
         dist_ptos(&A, &B)
    );

    printf("\nTecle ENTER para encerrar... \n");
    c = fgetc(stdin);
    printf("c= %c\n\n\n", c);
    return 0;
}

arfneto · 16 de janeiro de 2021

2 horas atrás, devair1010 disse:

o código está funcionando bem e faz o cálculo certo , e você colocou o fgetc no final para esperar um pouco para visualizar o resultado ? , mas aqui não deu assim não , ele passa direto para o final

Claro, é o teorema de pitágoras. Apenas a fórmula e mais umas coisas que eu disse estavam erradas.

fgetc() lê uma letra. Só coloquei para tirar o system(). Nem pensei na verdade. Apenas não queria tirar system() e começar outra daquelas discussões sobre a bobagem que é (1) usar system e (2) usar um IDE que nao para o programa sozinho ao rodar numa console e (3) testar o programa apenas no IDE.

Mas é pra passar reto mesmo, já que o scanf() vai parar na segunda coordenada! My bad

Vamos ficar com o simples

#include <stdio.h>
#include <math.h>

typedef struct
{
	float linha;
	float coluna;

}	Ponto;

float dist_ptos(Ponto* A, Ponto* B)
{
	return (float)sqrt(
		(A->linha - B->linha) * (A->linha - B->linha) +
		(A->coluna - B->coluna) * (A->coluna - B->coluna)
	);
}

int 		ler_ponto(Ponto* P)
{
	printf("Digite linha e coluna do Ponto [separados por ao menos um espaco]: ");
	int res = scanf("%f %f", &P->linha, &P->coluna);
	if (res != 2) return 0;
	return 1;
};

int main(void)
{

	Ponto A;
	Ponto B;
	int res = ler_ponto(&A);
	if (res == 0)
	{
		printf("Nao conseguiu ler as coordenadas de A :(\n");
		return -1;
	};

	res = ler_ponto(&B);
	if (res == 0)
	{	printf("Nao conseguiu ler as coordenadas de B :(\n");
		return -1;
	};

	printf("\nDistancia entre (%.2f, %.2f) e (%.2f, %.2f) = %.5f\n",
		A.linha, A.coluna,
		B.linha, B.coluna,
		dist_ptos(&A, &B)
	);
	return 0;
}