我想定义一个可以在不同地方(在文件范围内)调用的宏，以便创建可以执行某些操作的函数。 (在下面的示例中，函数只是打印一条消息，但当然我的真正意图是做一些其他有用的事情。)挑战在于我想要一些“管理器”功能(在我的示例中，它只是 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

#define START_REGISTRATION                                          \
template<int lo, int hi>                                            \
struct LastReg {                                                    \
  enum {                                                            \
     LINE_NUM = LastReg<(lo + hi)/2 + 1, hi>::LINE_NUM ?            \
        static_cast<int>(LastReg<(lo + hi)/2 + 1, hi>::LINE_NUM) :  \
        static_cast<int>(LastReg<lo, (lo + hi)/2>::LINE_NUM)        \
  };                                                                \
};                                                                  \
template<int l>                                                     \
struct LastReg<l, l> {                                              \
   enum { LINE_NUM = 0 };                                           \
};                                                                  \
template<int l>                                                     \
struct PrevReg {                                                    \
   enum { LINE_NUM = LastReg<__LINE__ + 1, l - 1>::LINE_NUM };      \
};                                                                  \
template<int l> void Register() {}                                  \
template<int l> void Register()  /* force semicolon */


#define REGISTER(msg)                                               \
template<>                                                          \
struct LastReg<__LINE__, __LINE__> {                                \
   enum { LINE_NUM = __LINE__ };                                    \
};                                                                  \
template<>                                                          \
void Register<__LINE__>()                                           \
{                                                                   \
   cout << __LINE__ << ":" << #msg << endl;                         \
   Register<PrevReg<__LINE__>::LINE_NUM>();                         \
}                                                                   \
template<> void Register<__LINE__>()  /* force semicolon */


#define END_REGISTRATION                                            \
void RegisterAll()                                                  \
{                                                                   \
   Register<PrevReg<__LINE__>::LINE_NUM>();                         \
}                                                                   \
void RegisterAll()  /* force semicolon */


START_REGISTRATION;

REGISTER(message 1);

REGISTER(message 2);

END_REGISTRATION;


int main()
{
   RegisterAll();
}

最佳答案

您面临的问题是您正在对 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 个级别。这是可行的。

关于c++ - 消除 C++ 中的递归模板实例化，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/6150787/