【问题标题】:How can I check if a templated method was called at compile-time?如何检查是否在编译时调用了模板化方法?
【发布时间】:2019-01-31 19:19:03
【问题描述】:

我正在写一个实体entity component system game engine。作为其中的一部分,我编写了一个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{
};

如 cmets 中所述,我在 template&lt;class T&gt;Manager::createDerived() 中有代码,用于检查 Base 的特定实现是否已使用 template&lt;class T&gt;Manager::registerDerived() 注册,如果尚未注册,则会引发错误。这个检查是微不足道的,为了简单起见,代码示例中省略了。

这是我的问题:是否可以将此检查移至编译时,而不是等到运行时?似乎在运行时应该有足够的信息来做出这个决定。

到目前为止,我已经探索/阅读了有关 SFINAE 的信息,这似乎是可以采用的方法,但我无法弄清楚如何使这些成语在这种特定情况下发挥作用。 This link 很好地概述了基本的 SFINAE 习语,this SO 问题提供了一些很好的代码 sn-ps,最后 This blog post 似乎几乎解决了我的确切情况。

这是一个完整的示例,我尝试实现这些链接中的信息:

#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),而不是等到运行时才检测到错误?

**

【问题讨论】:

  • 恐怕,这在编译时是不可能的。您不能在编译时将“状态”附加到非constexpr 对象,也不能在编译时读取该状态。
  • Manager 是单身人士吗?
  • register() 替换create() 后跟create() 有什么问题(但在一个函数调用中完成)?假设多个register&lt;T&gt;() 不会导致任何问题。
  • 目前还不清楚您为什么要这样做(在创建之前和之前分别键入注册)。你能提供一个简单的用例,这是最惯用的解决方案吗?
  • 是的,我可以努力更新我的答案以使这一点更清楚。我的经理确保每个 Derived 都有唯一的 ID 和唯一的字符串表示,这有助于数据的(反)序列化

标签: c++ c++11 templates template-meta-programming introspection


【解决方案1】:

我认为这不可能以便携/可靠的方式。

如果您对仅编译时注册感兴趣,我建议将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 };

【讨论】:

  • 感谢您的详细回复。您能否指出任何类似于this wiki 的资源,其中详细说明了您正在使用的一些技术?我对所有这些模板感到有点不适应,我想确保我了解解决方案的作用,而不是盲目地使用它。
  • 您对typeInList 的定义是否包含前向声明和3 个特化,而不是基本情况(失败),然后是两个特化(成功和递归)?此外,对于 struct 的基数,显式 public 是多余的。
  • @Deduplicator - 也许可以用更好的方式编写,但是......三个专业化中没有一个可以用作通用(非专业化)版本:基本情况,因为只有一个参数(如果另一个需要至少两个);另外两个是因为需要两个参数(基本情况只需要一个)。而且我知道public 是默认的,所以是多余的,但我发现它更清晰。
  • @wesanyer - 不,抱歉:我不知道类似的资源可以涵盖它;但你试图理解你在使用什么是对的。我想自定义类型特征typeInList 中难以理解的部分。我建议搜索“模板专业化”。
  • @max66:失败案例是一个很好的基本案例,请忽略理论上的尾巴。然后,这两个专业化处理它为空。见:template &lt;class, class...&gt; struct in_list : std::false_type {}; template &lt;class T, class... Ts&gt; struct in_list&lt;T, T, Ts...&gt; : std::true_type { using type = T; }; template &lt;class T, class U, class... Ts&gt; struct in_list&lt;T, U, Ts...&gt; : in_list&lt;T, Ts...&gt; {};
【解决方案2】:

恕我直言,您遇到了设计问题。 registerDerived&lt;Derived&gt;() 是调用createDerived&lt;Derived&gt;()先决条件这一事实应在代码中(而不仅仅是在文档中)表示,这样就不可能进行未注册的创建。

实现此目的的一种方法是通过在注册时发布并在创建时需要的注册文件。例如

#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&lt;Derived&gt; 以进行任何创建。但是,在这个简单的示例中,先注册后创建的概念本身并不明智,因为以下代码始终可以工作并且无需事先注册(另请参阅我在 cmets 中的问题):

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

如果每次注册比我的简单示例更昂贵,那么您可以在尝试注册之前检查(使用unordered_set&lt;type_index&gt; 如上所述)是否注册了Derived 类型。

【讨论】:

    猜你喜欢
    • 1970-01-01
    • 1970-01-01
    • 2015-08-24
    • 1970-01-01
    • 2017-01-21
    • 1970-01-01
    • 2018-05-24
    • 1970-01-01
    • 2011-05-09
    相关资源
    最近更新 更多