first.cpp

#include <functional>
#include <algorithm>
#include <iostream>
#include <utility>
#include <float.h>
#include <string>
#include <vector>
#include <cmath>

typedef struct {
	int wheels, passengers, size, power;
} data;

class abstract_transporter {
	protected:
		const data reference;
	public:
		const std::string name;
		abstract_transporter(const std::string name, const data reference) :
							reference (reference),
							name (name)
		{};

		friend std::ostream& operator<< (std::ostream& stream, const abstract_transporter& vehicle); 

		virtual float test_euclid(const data input) {
			float l = 0;

			l = pow((reference.passengers - input.passengers), 2.0)
			  + pow((reference.wheels - input.wheels), 2.0)
			  + pow((reference.power - input.power), 2.0)
			  + pow((reference.size - input.size), 2.0);

			l = sqrt(l);

			return l;
		};

		virtual float test_mekkel(const data input) {
			float l = 0;

			l = pow((reference.passengers - input.passengers), 4.0)
			  + pow((reference.wheels - input.wheels), 4.0)
			  + pow((reference.power - input.power), 4.0)
			  + pow((reference.size - input.size), 4.0);

			l = sqrt(l);

			return sqrt(l);
		};
};

std::ostream& operator<< (std::ostream& stream, const abstract_transporter& vehicle) {
	stream << vehicle.name << ": "
		   << "\t" << vehicle.reference.wheels 
		   << "\t" << vehicle.reference.passengers
		   << "\t" << vehicle.reference.size
		   << "\t" << vehicle.reference.power;

	return stream;
};

class bus : public abstract_transporter {
	public:
		bus() : abstract_transporter("Автобус", {4, 70, 20, 150}) {};
};

class car : public abstract_transporter {
	public:
		car(): abstract_transporter("Автомобиль", {4, 5, 4, 100}) {};
};

class helicopter : public abstract_transporter {
	public:
		helicopter() : abstract_transporter("Вертолёт", {1, 10, 50, 300}) {};
};

class bicycle : public abstract_transporter {
	public:
		bicycle() : abstract_transporter("Велосипед", {2, 1, 1, 1}) {};
};

abstract_transporter tester(std::vector<abstract_transporter*> vehicles, std::function<float(abstract_transporter*)> lambda) {
	std::vector<float> temp(vehicles.size());

	std::transform(vehicles.begin(), vehicles.end(), temp.begin(), lambda);

	auto r = std::min_element(temp.begin(), temp.end());

	return *(vehicles.at(std::distance(temp.begin(), r)));
}

int main() {
	std::vector<abstract_transporter*> vehicles;

	vehicles.push_back(new helicopter());
	vehicles.push_back(new bicycle());
	vehicles.push_back(new bus());
	vehicles.push_back(new car());

	std::cout<<"Эталонные данные; количество колёс, пассажиров, размер, мощность"<<std::endl;
	for(auto x : vehicles) {
		std::cout << *x << std::endl;
	}
	
	data input = {0, 0, 0, 0};
	std::cout << "Введите данные: ";
	std::cin >> input.wheels >> input.passengers >> input.size >> input.power;

	std::cout << "Скорее всего это "
			  << tester(vehicles, std::function<float(abstract_transporter*)>(
			  						[input](abstract_transporter* x){
			  							return x->test_euclid(input);
			  						})).name
			  << " (Евклид)"
			  << std::endl;

	std::cout << "Скорее всего это "
			  << tester(vehicles, std::function<float(abstract_transporter*)>(
			  						[input](abstract_transporter* x){
			  							return x->test_mekkel(input);
			  						})).name
			  << " (Менекль)"
			  << std::endl;

	return 0;
}