Как я могу проверить, был ли шаблонный метод вызван во время компиляции? - PullRequest
Новая
       25

Как я могу проверить, был ли шаблонный метод вызван во время компиляции?

0 голосов
/ 25 августа 2018

Я пишу сущность игровой движок системы компонентов сущностей . В качестве части этого я написал класс Manager, который будет регистрировать различные реализации IBase и, позже, позволю мне реализовать эти реализации. Ниже приведен пример того, как я хочу это использовать. 

class Manager{
    public:
        template<class T>
        void registerDerived()
        { /*Register a Derived with the Manager*/ };

        template<class T>
        T createDerived()
        {   /*if T is not registered, throw an error*/
            return T();};
};

struct IBase{
};

struct Derived1 : public IBase{
};

struct Derived2 : public IBase{
};

Как отмечено в комментариях, у меня есть код в template<class T>Manager::createDerived(), который проверяет, была ли зарегистрирована конкретная реализация Base с использованием template<class T>Manager::registerDerived(), и, если она не была зарегистрирована, выдает ошибку. Эта проверка тривиальна и не включена в пример кода, чтобы упростить задачу.

Вот мой вопрос: можно ли перенести эту проверку во время компиляции, а не ждать до времени выполнения? Похоже, что во время выполнения должно быть достаточно информации, чтобы сделать это определение.

До сих пор я изучал / читал о SFINAE, который кажется подходом, но я не могу понять, как заставить эти идиомы работать в данном конкретном случае. Эта ссылка дает хороший обзор основной идиомы SFINAE, этот вопрос SO дает несколько хороших фрагментов кода, и, наконец, Этот пост в блоге , кажется, касается почти моего точного ситуация.

Вот полный пример, который является моей попыткой реализовать информацию, найденную в этих ссылках: 

#include <iostream>

class Manager{
    public:
        template<class T>
        void registerDerived()
        { /*Register a Derived with the Manager*/ }

        template<class T>
        T createDerived()
        {   /*if T is not registered, throw an error*/
            return T();}
};

struct IBase{
};

struct Derived1 : public IBase{
};

struct Derived2 : public IBase{
};


template<typename T>
struct hasRegisterDerivedMethod{
    template <class, class> class checker;

    template <typename C>
    static std::true_type test(checker<C, decltype(&Manager::template registerDerived<T>)> *);

    template <typename C>
    static std::false_type test(...);

    typedef decltype(test<T>(nullptr)) type;
    static const bool value = std::is_same<std::true_type, decltype(test<T>(nullptr))>::value;
};


int main(){
    Manager myManager;
    myManager.registerDerived<Derived1>();
    // whoops, forgot to register Derived2!
    Derived1 d1 = myManager.createDerived<Derived1>(); // compiles fine, runs fine. This is expected.
    Derived2 d2 = myManager.createDerived<Derived2>(); // compiles fine, fails at runtime (due to check in createDerived)

    std::cout << std::boolalpha;

    // expect true, actual true
    std::cout << "Derived1 check = " << hasRegisterDerivedMethod<Derived1>::value << std::endl;
    // expect false, actual true
    std::cout << "Derived2 check = " << hasRegisterDerivedMethod<Derived2>::value << std::endl;

    return 0;
}

**

TL; DR

Как я могу изменить приведенный выше код для получения ошибки во время компиляции (вероятно, с использованием static_assert) вместо ожидания времени выполнения для обнаружения ошибки?

**

Ответы [ 2 ]

0 голосов
/ 26 августа 2018

ИМХО, у вас проблема дизайна.Тот факт, что registerDerived<Derived>() является обязательным условием для вызова createDerived<Derived>(), должен быть выражен в коде (а не только в документации), так что незарегистрированное создание невозможно.

В одну сторонуДля этого необходимо получить регистрационный документ, который выдается при регистрации и требуется при создании.Например, 

#include <typeinfo>
#include <typeindex>
#include <unordered_set>

struct Manager {

    // serves as registration document
    template<typename T>
    class ticket { friend struct Manager; };

    // use SFINAE to restrict T to a derived class (assumed C++14)
    template<typename T>
    std::enable_if_t<std::is_base_of<Manager,T>::value, ticket<T> >
    registerDerived()
    {
        registeredTypes.insert(std::type_index(typeid(T)));
        return {};
    }

    template<typename T, typename... Args>
    T createDerived(ticket<T>, Args&&...args)
    {
        return T(std::forward<Args>(args)...);
    }

  private:
    std::unordered_set<std::type_index> registeredTypes;
};

struct Derived1 : Manager {};
struct Derived2 : Manager { Derived2(int); }

int main() {
    Manager manager;
    auto t1 = manager.registerDerived<Derived1>();
    auto t2 = manager.registerDerived<Derived2>();
    auto x1 = manager.createDerived(t1);
    auto x2 = manager.createDerived(t2,7);
}

Обратите внимание, что объект t, вероятно, оптимизирован.

Конечно, этот код отличается от вашего, так как для его переноса требуется ticket<Derived>.любое творение.Однако сама концепция регистрации с последующим созданием не имеет смысла в этом простом примере, так как следующий код всегда будет работать и выполнять без предварительной регистрации (см. Также мой вопрос в комментариях): 

template<typename T, typename...Args>
T Manager::create(Args&&..args)
{
    return createDerived(register<T>(),std::forward<Args>(args)...);
}

Если регистрация на сеанс является более дорогим процессом, чем в моем простом примере, то вы можете проверить (используя unordered_set<type_index>, как указано выше), зарегистрирован ли тип Derived, прежде чем пытаться это сделать.

0 голосов
/ 25 августа 2018

Я не думаю, что это возможно переносимым / надежным способом.

Если вы заинтересованы в регистрации только во время компиляции, я предлагаю сделать Manager класс шаблона, в котором параметры шаблона являются зарегистрированнымитипов.

Я имею в виду ... если вы пишете пользовательские черты типа следующим образом 

template <typename, typename ...>
struct typeInList;

template <typename T0, typename T1, typename ... Ts>
struct typeInList<T0, T1, Ts...> : public typeInList<T0, Ts...>
 { };

template <typename T0, typename ... Ts>
struct typeInList<T0, T0, Ts...> : public std::true_type
 { using type = T0; };

template <typename T0>
struct typeInList<T0> : public std::false_type
 { };

template <typename ... Ts>
using typeInList_t = typename typeInList<Ts...>::type;

или (как предложено Deduplicator (спасибо!)) более компактным способом 

// ground case: in charge only when `typename...` variadic list
// is empy; other cases covered by specializations
template <typename, typename...>
struct typeInList : public std::false_type
 { };

template <typename T0, typename T1, typename ... Ts>
struct typeInList<T0, T1, Ts...> : public typeInList<T0, Ts...>
 { };

template <typename T0, typename ... Ts>
struct typeInList<T0, T0, Ts...> : public std::true_type
 { using type = T0; };

template <typename ... Ts>
using typeInList_t = typename typeInList<Ts...>::type;

вы можете использовать его для включения / выключения SFINAE createDerived() следующим образом 

template <typename ... Ts>
struct Manager
 {
   template <typename T>
   typeInList_t<T, Ts...> createDerived ()
    { return T(); }
 };

и hasRegisterDerivedMethod можно записать следующим образом 

template <typename, typename>
struct hasRegisterDerivedMethod;

template <typename ... Ts, typename T>
struct hasRegisterDerivedMethod<Manager<Ts...>, T>
   : public typeInList<T, Ts...>
 { };

К сожалению, этоработает во время компиляции, но не во время выполнения, поэтому, если вам нужно решение, которое работает как во время компиляции, так и во время выполнения, это решение не для вас.

Ниже приведен полный рабочий пример 

#include <iostream>

template <typename, typename ...>
struct typeInList;

template <typename T0, typename T1, typename ... Ts>
struct typeInList<T0, T1, Ts...> : public typeInList<T0, Ts...>
 { };

template <typename T0, typename ... Ts>
struct typeInList<T0, T0, Ts...> : public std::true_type
 { using type = T0; };

template <typename T0>
struct typeInList<T0> : public std::false_type
 { };

template <typename ... Ts>
using typeInList_t = typename typeInList<Ts...>::type;

template <typename ... Ts>
struct Manager
 {
   template <typename T>
   typeInList_t<T, Ts...> createDerived ()
    { return T(); }
 };

struct IBase { };
struct Derived1 : public IBase{ };
struct Derived2 : public IBase{ };


template <typename, typename>
struct hasRegisterDerivedMethod;

template <typename ... Ts, typename T>
struct hasRegisterDerivedMethod<Manager<Ts...>, T>
   : public typeInList<T, Ts...>
 { };

int main ()
 {
   Manager<Derived1> myManager;
   // whoops, forgot to register Derived2!

   Derived1 d1 = myManager.createDerived<Derived1>();

   //Derived2 d2 = myManager.createDerived<Derived2>(); // compilation error!

   std::cout << std::boolalpha;

   std::cout << "Derived1 check = "
      << hasRegisterDerivedMethod<decltype(myManager), Derived1>::value
      << std::endl; // print true

   std::cout << "Derived2 check = "
      << hasRegisterDerivedMethod<decltype(myManager), Derived2>::value
      << std::endl; // print false
 }

Не по теме: вместо 

static const bool value = std::is_same<std::true_type, decltype(test<T>(nullptr))>::value;

можно написать 

static constexpr bool value { type::value };
...