我可以使用模板实例化副作用吗？

时间：2015-01-20 18:50:35

标签： c++ templates instantiation

所以，让我们从做我想要的代码开始，但我想教一个新技巧（如果可能的话）。

#include <string>
#include <iostream>

class A {}; class B {}; class C {}; class D {};

template<typename T> struct traits { };
template<> struct traits<A> { static std::string code() {return "class A";}};
template<> struct traits<B> { static std::string code() {return "class B";}};
template<> struct traits<C> { static std::string code() {return "class C";}};
template<> struct traits<D> { static std::string code() {return "class D";}};

std::string RegisterClass(const std::string & c){
    std::cout << "Registering " << c << '\n';
    return c;
}

template<typename T> void printMe() {
    static std::string t = RegisterClass(traits<T>::code());
    std::cout << "Printing " << traits<T>::code() << '\n';
}

int main(void)
{
    printMe<B>(); 
    printMe<B>(); 
    printMe<C>(); 
    return 0;
}

它的输出正如人们所期望的那样 - “注册”仅发生一次，仅适用于模板实例化的那些类型：

Registering class B
Printing class B   
Printing class B   
Registering class C
Printing class C

我想拥有的只是在第一次调用printMe函数之前，只有用于“注册”自己的类。所以输出看起来像这样：

Registering class B
Registering class C
Printing class B   
Printing class B   
Printing class C

从表面上看，这似乎是可能的。编译器“知道”用于实例化的类型。如果我能够将这些信息存储在某些全局或静态内容中，那么我只需在main()的开头处理它。

但是到目前为止，我所有试图颠覆编译器实际操作的尝试都失败了。这让我怀疑这是故意的。那么'我可以有模板实例化副作用吗？他问道，期待答案'不'？

编辑：我很抱歉，但我真的没能在那句话中清楚表达自己。在上面的示例中，我不需要注册A,B,C and D - 我只需要B and C，我希望编译器能够以某种方式自己解决这个问题。

5 个答案:

答案 0 :(得分：3)

是的，使用在命名空间作用域中实例化的静态成员变量。例如：

template<typename T>
struct RegisterClass
{
    static RegisterClass instance;
    RegisterClass()
    {
        std::cout << "Registering " << traits<T>::code() << '\n';
    }
    static RegisterClass& doRegister() { return instance; }
};
template<typename T>
RegisterClass<T> RegisterClass<T>::instance;

template<typename T> void printMe() {
    RegisterClass<T>::doRegister();
    std::cout << "Printing " << traits<T>::code() << '\n';
}

Working example

使用静态成员函数doRegister的唯一原因是避免使用未使用的变量发出警告。

另见How does the scheme below garantees there'll be just one definition for the objects cin, cout, ...?有关全局对象和初始化顺序的一些皱纹。

答案 1 :(得分：1)

您可以通过创建一个辅助类来实现，该类的构造函数负责注册类。然后在外部作用域中创建一个辅助类的实例。

#include <string>
#include <iostream>

class A {}; class B {}; class C {}; class D {};

template<typename T> struct traits { };
template<> struct traits<A> { static std::string code() {return "class A";}};
template<> struct traits<B> { static std::string code() {return "class B";}};
template<> struct traits<C> { static std::string code() {return "class C";}};
template<> struct traits<D> { static std::string code() {return "class D";}};

template<typename T> 
void registerClass(){
    std::cout << "Registering " << traits<T>::code() << '\n';
}

template<typename T> void printMe() {
    std::cout << "Printing " << traits<T>::code() << '\n';
}

struct Init
{
   Init();
};

Init::Init()
{
   registerClass<A>();
   registerClass<B>();
   registerClass<C>();
   registerClass<D>();
}

static Init init;

int main(void)
{
    printMe<B>(); 
    printMe<B>(); 
    printMe<C>(); 
    return 0;
}

答案 2 :(得分：1)

添加一个静态成员变量并实例化它。

namespace {
    template<typename T>
    class registrar {
    public:
        registrar() {
            std::string t = RegisterClass(traits<T>::code());
        }
    };
}
template <class type> struct traits {
    virtual std::string code() = 0; // override this
private:
    static registrar m_registrar;
};
registrar traits<A>::m_registrar;

通过这种方式，T的任何给定traits<T>因此会产生在运行时启动时调用registrar<T>::registrar()的副作用。

答案 3 :(得分：0)

这很有效，但是答案很糟糕，因为我不确定静态变量为何如此奇怪。

#include <iostream>
using namespace std;

template <typename T>
class Registrar {
public:
    Registrar();
};

template <typename D>
struct SelfRegistrar {
   static Registrar<D> d_;
    SelfRegistrar(){
        cout << &d_ << endl;
    }
};



//for some reason I don't understand need some reference to d, opening another question...
class A : SelfRegistrar<A> { static void* foo() {return &d_;} };
class B : SelfRegistrar<B> { static void* foo() {return &d_;}};
class C : SelfRegistrar<C> { static void* foo() {return &d_;}};
class D : SelfRegistrar<D> { static void* foo() {return &d_;}};

template<typename T> struct traits { };
template<> struct traits<A> { static std::string code() {return "class A";}};
template<> struct traits<B> { static std::string code() {return "class B";}};
template<> struct traits<C> { static std::string code() {return "class C";}};
template<> struct traits<D> { static std::string code() {return "class D";}};

template <typename D>
Registrar<D> SelfRegistrar<D>::d_{};

std::string RegisterClass(const std::string & c){
    std::cout << "Registering " << c << '\n';
    return c;
}

template<typename T> void printMe() {
    std::cout << "Printing " << traits<T>::code() << '\n';
}

template <typename D>
Registrar<D>::Registrar()
{
   std::string c = traits<D>::code();
   std::cout << "Registering " << c << '\n';
}

int main() {
    // your code goes here
    printMe<B>(); 
    printMe<B>(); 
    printMe<C>(); 
    return 0;
}

答案 4 :(得分：0)

有时从基类派生更方便，而不是像这样使用嵌入式或附加的助手类。根据您的需要，这种方法有时可以使事情变得更简单/更清洁，更可重复使用。

例如：

#include <string>
#include <iostream>
#include <typeinfo>

// Forward declaration for "traits" wrapper class.  If you wanted to, you 
// could to change the self_registering template to not use a wrapper class, 
// default a wrapper but allow other specializations, etc.
template<typename T> struct traits;

template<typename wrappedClass>
struct self_registering {
    self_registering() {};
    virtual ~self_registering() {};
    static bool isRegistered() { return registered; }

private:
    typedef traits<wrappedClass> WrappedClass_;
    static bool doRegistration() {
        std::cout << "Default-registering " << WrappedClass_().code() << '\n';
        return true;
    };
    static const bool registered;
};
template<typename T>
const bool self_registering<T>::registered 
         = self_registering<T>::WrappedClass_().doRegistration();

// our traits wrapper class...
template<typename T> 
struct traits : self_registering<T>   {
    static std::string code() { return typeid(T).name(); };
};

// Well, that's pretty much it. Time to use it:

// a few classes we're going to (maybe) want self-registered...
class A {}; class B {}; class C {}; class D {};
class E {}; class F {}; class G {}; class H {};

// provide custom registration for class H:
template<> struct traits<H> : self_registering<H> { 
    static std::string code() { return "class H"; }

    bool doRegistration() {
        std::cout << "Private-registering " << code() << "\n";
        // do something here like H::register()...
        return true;
    };
};

template<typename T>
void printMe() {
    static bool isRegistered = traits<T>::isRegistered();
    (void)isRegistered; // shut gcc up about unused variable
    std::cout << "Printing " << traits<T>::code() << '\n';
}

int main(void)
{
    printMe<B>(); 
    printMe<B>(); 
    printMe<C>(); 

    printMe<H>(); 

    return 0;
}

使用基于模板的纯自我注册方法，一个缺点是如果你的所有类成员函数都是static，你将在某个时候需要以某种方式强制注册（如在其他答案中所见 - 例如RegisterClass（）等）。

上面的代码通过简单地引用registered中的静态成员变量printMe()的值来实现这一点，迫使编译器初始化它（它通过调用registration()来完成）。该值分配给static bool，因此在启动时每个类只应注册一次。

尽管在翻译单元之间不能保证注册顺序，但它在C ++ 11下应该是线程安全的（并且，如果你的代码在初始化静态对象之前没有多线程，那么前C语言++ 11）。如上所述，缺点是registered成员变量必须在代码中的某处中引用。

使用VS2012进行编译/测试：

C:\tmp>cl /nologo /EHsc  /W4 so-misc.cpp
so-misc.cpp

C:\tmp>so-misc
Default-registering class B
Default-registering class C
Private-registering class H
Printing class B
Printing class B
Printing class C
Printing class H

和gcc 4.7.2 as：

$ gcc -std=c++11 -lstdc++ -Wall -pedantic so-misc.cpp
$ ./a.out | c++filt -t
Default-registering B
Default-registering C
Private-registering class H
Printing B
Printing B
Printing C
Printing class H

显然，你还可以做其他事情（进一步模板化self-registering以使包装类比traits更通用，一些清理等等），但这可能适合你一个开始。

相关问题
最新问题