Создание шаблона класса, который абстрагирует типы данных

Question

Я пишу набор алгоритмов для создания простой среды модульного тестирования.Класс с именем UnitTest создается с помощью строки символов с именем strng, которая описывает проводимый тест.Типы данных также передаются при создании объекта, что позволяет компилятору знать, какие типы данных передаются.Файл main.cpp и файл unit_test.hpp показаны ниже

// main.cpp file
#include <iostream>
#include <string>
#include <vector>
#include <array>
#include "unit_test.hpp"

int main(int argc, const char * argv[]) {
    std::vector<int> array_one = {1, 2, 3, 4};
    std::vector<float> array_two = {0.99, 1.99, 2.99, 3.99};

    std::string c ("Vector Test");
    UnitTest<int, float> q(c);
    double unc = 0.1;
    q.vectors_are_close(array_two, array_four, unc);
    return 0;
}


// unit_test.hpp file
#ifndef unit_test_hpp
#define unit_test_hpp
#endif /* unit_test_hpp */
#include <string>
#include <typeinfo>
#include <iostream>
#include <cmath>

template <class type1, class type2> class UnitTest {
public:
    unsigned long remain;
    std::string str;
    UnitTest(std::string strng) {
        str = strng;
        remain = 50 - str.length();
    };
    void vectors_are_close(std::vector<type1> &i, std::vector<type2> & j, double k);
    // ----------------------------------------------------------------
private:
    void is_close(type1 &i, type2 &j, double k);
};

template <class type1, class type2> void UnitTest<type1, type2>::
vectors_are_close(std::vector<type1> &i, std::vector<type2> &j, double k)
{
    if (i.size() != j.size()) {
        std::cout << str + std::string(remain, '.') +
        std::string("FAILED") << std::endl;
    }
    else {
        try {
            for (int a = 0; a < i.size(); a++){
                is_close(i[a], j[a], k);
            }
            std::cout << str + std::string(remain, '.') +
            std::string("PASSED") << std::endl;
        } catch (const char* msg) {
            std::cout << str + std::string(remain, '.') +
            std::string("FAILED") << std::endl;
        }
    }
}

template <class type1, class type2> void UnitTest<type1, type2>::
is_close(type1& i, type2& j, double k)
{
    double percent_diff = abs((j - i) / ((i + j) / 2.0));
    if (percent_diff > k) {
        throw "Number not in Tolerance";
    }

}

Показанная функция-член выполняет итерацию по контейнерам векторов, чтобы гарантировать, что данные в каждой индукции соответствуют второму векторув пределах определенной терпимости.Несмотря на то, что написанный код работает нормально, он требует от пользователя повторной обработки класса каждый раз, когда он хочет провести модульное тестирование с другим типом данных.

В этом случае экземпляр класса создается с помощью UnitTest<int, float>.Но в другом случае его можно создать с помощью UnitTest<float, double>.В этом подходе нет ничего плохого, но было бы более элегантно просто один раз создать экземпляр класса, например UnitTest< >, и просто заставить функцию vectors_are_close() принимать разные типы данных.Есть ли способ облегчить это поведение?

Answer 1

Если я правильно понял, вы не хотите создавать экземпляр класса с аргументами шаблона, а просто с именем класса UnitTest и хотите передавать различные экземпляры функций-членов в соответствии с различными type1 s и type2 s .

Если это так, вам не нужен класс шаблона, шаблонные функции-члены :

class UnitTest 
{
private:
    std::string str;
    unsigned long remain;
public:
    UnitTest(const std::string& strng)
        : str{ strng },
          remain{ 50 - str.size() }
    {}

    template <class type1, class type2>
    void vectors_are_close(const std::vector<type1> &i, const std::vector<type2> &j, double k)
    {
       // code
    }
private:
    template <class type1, class type2>
    void is_close(type1 i, type2 j, double k)
    {
      // code
    }
};

int main() 
{
    std::vector<int> array_one{ 1, 2, 3, 4 };
    std::vector<float> array_two{ 0.99f, 1.99f, 2.99f, 3.99f };
    std::vector<double> array_three{ 0.99, 1.99, 2.99, 3.99 };
    double unc = 0.1;

    UnitTest q{ std::string{"Vector Test"} }; // non-templated class
    // call different types of args to same UnitTest obj
    q.vectors_are_close(array_one, array_two, unc);
    q.vectors_are_close(array_one, array_three, unc);
    return 0;
}

---

Примечание : Если вы хотите создать экземпляр функций-членов только для целых чисел и чисел с плавающей запятой (или любой специальной группы типов), используйте SFINAE вместе с ними.

Например, следующие черты is_oky_types позволят вам создать функции-члены только для тех арифметических типов, которые действительны для тела функции.

#include <type_traits>

template<typename Type>
using is_oky_type = std::conjunction<
    std::is_arithmetic<Type>,
    std::negation<std::is_same<Type, bool>>,
    std::negation<std::is_same<Type, char>>,
    std::negation<std::is_same<Type, char16_t>>,
    std::negation<std::is_same<Type, char32_t>>,
    std::negation<std::is_same<Type, wchar_t>> >;

template<typename T, typename U>
using is_oky_types = std::conjunction<is_oky_type<T>, is_oky_type<U>>;

и в функциях-членах:

template <
    class type1,
    class type2,
    std::enable_if_t<is_oky_types<type1, type2>::value>* = nullptr
>
void  vectors_are_close(const std::vector<type1> &i, const std::vector<type2> &j, double k)
{
    // code...
}

template <class type1, class type2>
void is_close(
    type1 i,
    type2 j,
    double k,
    std::enable_if_t<is_oky_types<type1, type2>::value>* = nullptr)
{
    // code...
}