c++ - 如何检查在编译时是否调用了模板化方法？

Question

我正在写一个实体 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{
};

如评论中所述，我在 template<class T>Manager::createDerived() 中有代码检查 Base 的特定实现是否已使用 template<class T>Manager::registerDerived() 注册，如果尚未注册，则会引发错误。此检查很简单，为了简单起见，将其排除在代码示例之外。

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

到目前为止，我已经探索/阅读了有关 SFINAE 的信息，这似乎是一种可行的方法，但我无法弄清楚如何使这些习语在这种特定情况下发挥作用。 This link很好地概述了基本的 SFINAE 习语，this SO问题给出了一些很好的代码片段，最后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;
}

**

长话短说

我如何修改上面的代码以产生编译时错误(可能使用 static_assert )而不是等到运行时才检测到错误？

**

Answer 1

恕我直言，您遇到了设计问题。事实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在尝试这样做之前注册类型。