我想定义一个可以在不同位置（在文件范围内）调用的宏，以便创建执行某些操作的函数。 （在下面的例子中，函数只是打印一条消息，但当然我的真正意图是做一些其他有用的东西。）挑战是我想要一些“经理”功能（在我的例子中它只是{{1}以某种方式成功地使它们全部被调用（以任何顺序），而没有任何代码依赖于宏调用（当然，除了宏调用本身）。我的意思是，一旦编写了文件，另一个程序员就能够在不同的地方插入一些新的宏调用或者删除一些现有的调用，代码仍然可以在没有任何进一步改变的情况下工作。我意识到这可以使用静态对象完成，但我想探索一种不同的方法。我将使用一些模板技巧以及main()单调增加的事实。
__LINE__打印
#include <iostream>
using namespace std;
template<int i>
inline void f()
{
f<i-1>();
}
#define START_REGISTRATION \
template<> \
inline void f<__LINE__>() {} /* stop the recursion */ \
template<> void f<__LINE__>() /* force semicolon */
#define REGISTER(msg) \
template<> \
inline void f<__LINE__>() \
{ \
cout << #msg << endl; \
f<__LINE__ - 1>(); \
} \
template<> void f<__LINE__>() /* force semicolon */
// Unrelated code ...
START_REGISTRATION;
// Unrelated code ...
REGISTER(message 1);
// Unrelated code ...
REGISTER(message 2);
// Unrelated code ...
REGISTER(message 3);
// Unrelated code ...
// manager function (in this case main() )
int main()
{
f<__LINE__>();
}
正如所料。
这个解决方案有一些缺点。
message 3
message 2
message 1
两次。REGISTER，则会中断。#line。REGISTER的“虚拟”实例都被内联，否则运行时的调用堆栈深度将与f和START_REGISTRATION;之间的行数一样大。管理器。f<__LINE__>();的“虚拟”实例化全部内联，实例化的数量同样会很大。f的每个调用计算在先前调用中实例化的函数，从而仅实例化实际执行某些操作的函数。然后，过多的实例化将从函数模板转移到类模板，但是类实例化只会对编译器产生负担;它们不会触发任何代码生成。所以我真正关心的是问题7，问题是：有没有办法重构事物，以便编译器迭代地而不是递归地执行实例化。我也对不同的方法持开放态度（除了那些涉及静态对象的方法）。一个简单的解决方案是在管理器之前将所有注册组合在一起（或者添加一个REGISTER宏来结束注册块）但这会破坏我目的的重要部分（注册定义它的代码旁边的东西） ）。
编辑：已经提出了一些有趣的建议，但我担心自己并没有明确表达自己希望实现的目标。我真的对两件事情感兴趣：解决问题（即没有静态，每次注册单行，添加/删除注册时没有其他更改，虽然我忽略了这样说，但只有标准C ++ ---因此，没有提振）。正如我在下面的评论中所说，我的兴趣更具理论性：我希望学习一些新技术。因此，我真的希望专注于重组事情，以便消除（或至少减少）递归或找到满足我上面列出的约束的不同方法。
编辑2： MSalter的解决方案向前迈出了一大步。起初我认为每次注册都会产生线路的全部成本，但后来我意识到一个函数当然只能实例化一次，所以在实例化方面我们付出与线性搜索相同的价格，但是递归深度变为对数。如果我接触它，我将发布一个完整的解决方案，消除问题5-7。但是，看看它是否可以在恒定的递归深度中完成仍然会很好，最好的是，实例化的数量与调用的数量呈线性关系（a-la boost解决方案）。
编辑3：以下是完整的解决方案。
STOP_REGISTRATION答案 0 :(得分：5)
您遇到的问题是您正在对f<i>进行线性搜索，这会导致实例化过多。
解决方案是让f<i>致电g<i,0>。这又会调用g<i,i/2>和g<i/2,0>来调用g<i,i/2+i/4>，g<i/2+i/4,i/2>，g<i/2,i/4>和g<i/4, 0>。您当然会在g<__LINE__, __LINE__>内专注REGISTER()。
实例化f<65536>仍将导致65536个模板实例化（您有效地检查所有先前的65536行），但递归深度仅限于log（65536）或16个级别。那是可行的。
答案 1 :(得分：1)
也许是这样的：
template<typename T>
struct register_struct {
virtual void operator()() = 0;
register_struct();
register_struct *pNext;
};
template<typename T>
struct registry {
static register_struct<T> *chain;
static void walk() {
register_struct<T> *p = chain;
while (p) {
(*p)();
p = p->pNext;
}
}
};
template<typename T>
register_struct<T> *registry<T>::chain = NULL;
template<typename T>
register_struct<T>::register_struct()
{
pNext = registry<T>::chain;
registry<T>::chain = this;
}
#define DECL_REGISTRY(name) \
struct tag_##name { } ; \
void name() { registry<tag_##name>::walk(); }
#define JOIN_EXPAND(x, y) JOIN_EXPAND_2(x, y)
#define JOIN_EXPAND_2(x, y) x ## y
// Invoke REGISTER_PRINT at file scope!
#define REGISTER_PRINT(name, text) \
namespace { \
static struct : public register_struct<tag_##name> { \
void operator()() { \
std::cout << text << std::endl; \
} \
} JOIN_EXPAND(rs_##name##_, __LINE__); \
}
DECL_REGISTRY(foo);
REGISTER_PRINT(foo, "hello")
REGISTER_PRINT(foo, "world")
int main() {
foo();
return 0;
}
这将解决递归实例化问题，但您仍然只能在每行注册一次。但是，由于注册是在文件范围内，这应该（希望！）不是问题。
请注意，如果您希望在main()之前调用它们，则使用它是不安全的 - 您必须在使用之前允许静态构造函数完成。
答案 2 :(得分：0)
我曾经做过类似的事情，只实例化了一定数量的专业化。目标是将所有特化聚合成一个指针数组，并通过枚举使用单个方法访问它们，但您可以轻松地将其调整为您的类似（如我所想）的需要。
#include <iostream>
using namespace std;
class I {
public:
virtual ~I() {};
virtual void P(int index) = 0;
enum Item {
Item0,
Item1,
Item2,
Item3,
Item4,
ItemNum
};
};
template <class T> class A: public I {
public:
A() {
Unroll<A<T>, ItemNum> tmp (m_F);
}
virtual ~A() {
}
void P(int index) { (this->*m_F[index])(); }
protected:
typedef void (A<T>::*F)();
F m_F[ItemNum];
template <int N> void p() { cout << "default!" << endl; }
template <class W, int C> struct Unroll
{
Unroll(typename W::F * dest)
{
dest[C-1] = & W::template p<C-1>;
Unroll<W, C-1> u(dest);
}
};
};
template <class T> template <class W> struct A<T>::Unroll<W, 0>
{ public: Unroll(typename W::F * dest) {} };
class B: public A<B>
{
public:
};
template <> template <> void A<B>::p<A<B>::Item1>() { cout << 1 << endl; }
template <> template <> void A<B>::p<A<B>::Item2>() { cout << 2 << endl; }
template <> template <> void A<B>::p<A<B>::Item4>() { cout << "it hacking works!" << endl; }
int main()
{
I *a = new B;
for (int i = 0; i < I::ItemNum; ++i) a->P(i);
return 0;
}
答案 3 :(得分：0)
这是一个限制递归到实际注册的函数数量的解决方案。我没有使用__LINE__作为id，而是使用BOOST_PP_COUNTER，这是预处理器可用的递增计数器。
诀窍是你不能在宏内增加计数器，因为增量是通过包含头文件来完成的。因此，我不得不依赖于文件包含，因此需要两行而不是一行来注册消息（一行定义消息，一行实际注册它）。
以下是代码：
//register.hpp
#include <boost/preprocessor/slot/counter.hpp>
// general template function, not defined
template <unsigned int ID>
void f();
// base case, to stop recursion
template <>
void f<0>() {}
// macro to "hide" the name of the header to include (which should be in a
// "hidden" folder like "detail" in Boost
#define REGISTER() "actually_register_msg.hpp"
//actually_register_msg.hpp
#include <boost/preprocessor/stringize.hpp>
// increment the counter
#include BOOST_PP_UPDATE_COUNTER()
template<>
inline void f< BOOST_PP_COUNTER >()
{
std::cout << BOOST_PP_STRINGIZE( MSG_TO_REGISTER ) << std::endl;
f< BOOST_PP_COUNTER - 1 >(); // call previously registered function
}
// to avoid warning and registering multiple times the same message
#undef MSG_TO_REGISTER
// id of the last registered function
#define LAST_FUNCTION_ID BOOST_PP_COUNTER
// main.cpp
#define MSG_TO_REGISTER message 1
#include REGISTER()
#define MSG_TO_REGISTER message 2
#include REGISTER()
#define MSG_TO_REGISTER message 3
#include REGISTER()
int main()
{
f< LAST_FUNCTION_ID >();
}
与您的代码一样，打印
message 3
message 2
message 1
当然，注册电话不那么漂亮（一个#define和一个#include而不是一个宏调用），但你要避免很多的不必要模板实例化。