(2) Faça um programa com um registro Ponto, que contém os campos inteiros x e y. Faça uma função que recebe por parâmetro dois pontos, calcula e retorna a distância euclidiana entre eles (sqrt(x) = retorna a raiz quadrada de x e pow(x, 2)= retorna x^2 - ambas estão incluídas na biblioteca cmath = #include < cmath > ).

Distância Euclidiana:

p
Onde: q representa o ponto 1 e representa o ponto 2.
Na função main, crie um vetor de pontos alocado dinamicamente de tamanho N ( N informado pelo usuário) e leia as coordenadas de cada ponto. Use a função definida para calcular o tamanho do caminho definido pelos pontos, na ordem em que foram lidos.
O caminho é representado pela soma das distâncias entre os pontos.

Exemplo de entrada:

Informe o número de pontos: 4
Informe a coordenada x: 3
Informe a coordenada y: 3
Informe a coordenada x: 1
Informe a coordenada y: 1
Informe a coordenada x : -1
Informe a coordenada y: 2
Informe a coordenada x: 0
Informe a coordenada y: 3

Exemplo de saída:

Tamanho do caminho: 6.47871

Passo 1

Beleza, então o enunciado pede pra gente criar um programa em C++ que:
  1. Defina um “registro” (struct) chamado Ponto com dois inteiros x e y.
  2. Implemente uma função que receba dois Ponto e calcule a distância euclidiana d = raiz(px - qx)^2 + (py - qy)^2 usando sqrt e pow da <cmath>.
  3. No main, peça pro usuário quantos pontos ele quer (N), aloque dinamicamente um vetor de Ponto de tamanho N, leia cada coordenada e some as distâncias entre o ponto 1→2, 2→3, …, (N−1)→N. Por fim, imprima o “tamanho do caminho”.
Matéria envolvida:
  • Structs em C++
  • Alocação dinâmica (new[] e delete[])
  • Funções e passagem de parâmetros
  • Uso de <cmath>: sqrt, pow
  • Loops e leitura/saída

Passo 2

Vamos começar definindo o tipo Ponto. Em C++, um struct é só um jeito de agrupar variáveis de diferentes tipos sob um nome só. Aqui a gente quer algo assim:
struct Ponto {
    int x;
    int y;
};
Isso faz com que você possa dizer Ponto a; e ter a.x e a.y.

Passo 3

Agora a função de distância. A fórmula é a clássica da geometria:
d(p,q) ;=; raiz(px - qx)^2 + (py - qy)^2
Em C++ vamos usar std::pow(valor, 2) pra elevar ao quadrado e std::sqrt(...) pra raiz.
#include <cmath>  // já garante pow e sqrt

double distancia(const Ponto &p, const Ponto &q) {
    double dx = p.x - q.x;             // diferença em x
    double dy = p.y - q.y;             // diferença em y
    return std::sqrt(std::pow(dx, 2) + std::pow(dy, 2));
}
Explicando: dx e dy viram double só pra gente não perder precisão na raiz quadrada.

Passo 4

No main, a gente precisa:
  1. Perguntar “Informe o número de pontos: ” e ler int N.
  2. Alocar um vetor Ponto *vet = new Ponto[N];.
  3. Fazer um for de i = 0 até N-1 pedindo vet[i].x e vet[i].y.
Esse vetor dinâmico é útil quando a gente só sabe N em tempo de execução.

Passo 5

Agora, para calcular o comprimento do caminho, basta somar a distância de vet[i-1] até vet[i] para i de 1 a N-1:
double caminho = 0.0;
for(int i = 1; i < N; ++i) {
    caminho += distancia(vet[i-1], vet[i]);
}
A variável caminho recebe a soma acumulada.
Depois disso, lembramos de delete[] vet; pra liberar a memória.

Passo 6

Por fim, mostramos o resultado formatado com, digamos, 5 casas decimais (como no exemplo):
#include <iomanip>  // para setprecision

std::cout << "Tamanho do caminho: "
          << std::fixed << std::setprecision(5)
          << caminho << std::endl;

Resposta

#include <iostream>
#include <cmath>
#include <iomanip>

struct Ponto {
    int x;
    int y;
};

double distancia(const Ponto &p, const Ponto &q) {
    double dx = p.x - q.x;
    double dy = p.y - q.y;
    return std::sqrt(std::pow(dx, 2) + std::pow(dy, 2));
}

int main() {
    int N;
    std::cout << "Informe o número de pontos: ";
    std::cin >> N;

    // Aloca dinamicamente
    Ponto *vet = new Ponto[N];

    // Lê as coordenadas
    for (int i = 0; i < N; ++i) {
        std::cout << "Informe a coordenada x: ";
        std::cin >> vet[i].x;
        std::cout << "Informe a coordenada y: ";
        std::cin >> vet[i].y;
    }

    // Calcula o tamanho do caminho
    double caminho = 0.0;
    for (int i = 1; i < N; ++i) {
        caminho += distancia(vet[i-1], vet[i]);
    }

    // Libera a memória
    delete[] vet;

    // Mostra o resultado
    std::cout << "Tamanho do caminho: "
              << std::fixed << std::setprecision(5)
              << caminho << std::endl;

    return 0;
}

Exercícios relacionados