main.cpp

#include <functional> // 1.1.7.28
#include <algorithm>
#include <iostream>
#include <utility>
#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_euqlid(const data input) {
			double l = 0;

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

			return (float)sqrt(l);
		};

		virtual float test_mekkel(const data input) {
			double l = 0;
	
			l = pow((reference.wheels - input.wheels), 4.0)
				+ pow((reference.passengers - input.passengers), 4.0)
				+ pow((reference.size - input.size), 4.0)
				+ pow((reference.power - input.power), 4.0);
	
			return (float)sqrt(sqrt(l));
		};

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

			  l = abs(reference.wheels - input.wheels)
				+ abs(reference.passengers - input.passengers)
				+ abs(reference.size - input.size)
				+ abs(reference.power - input.power);

			return l;
		};

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

			  l = (abs(reference.wheels - input.wheels) / abs(reference.wheels + input.wheels))
				+ (abs(reference.passengers - input.passengers) / abs(reference.passengers + input.passengers))
				+ (abs(reference.size - input.size) / abs(reference.size + input.size))
				+ (abs(reference.power - input.power) / abs(reference.power + input.power));

			return 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, 15}) {};
};

class trolley : public abstract_transporter {
	public:
		trolley(): abstract_transporter("Трамвай", {4, 70, 40, 20}) {};
};

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

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 trolley());
	vehicles.push_back(new bicycle());
	vehicles.push_back(new bus());

	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_euqlid(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;

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

	std::cout   << "Скорее всего это "
				<< tester(vehicles, std::function<float(abstract_transporter*)>(
						[input](abstract_transporter* x){
							return x->test_kammberr(input);
						})).name
				<< " (Каммберр)"
				<< std::endl;

	return 0;
}