小编svo*_*ron的帖子

我正在尝试使用编译时生成的数组来实现快速函数调度程序,以便能够在运行时在O(1)中使用它.

一些代码行只是为了澄清:

template<int i>
void f()
  {
  // do stuff 
  }

// specialized for every managed integer 
template<>
void f<1>
{
// do stuff
}

Dispatcher<1,5,100,300> dispatcher;  
dispatcher.execute(5); // this should call f<5>()

我们将调度器的输入数量(在这种情况下为4)调用N,并且在这种情况下调度调度器输入(300)的最大值.

我已经能够创建一个大小等于M的数组.这利用了这样一个事实:在运行时你可以做类似的事情:

dispatcher.execute(5) -> internalArray[5]();

这当然是有效的,但对于大尺寸的阵列来说这是不可行的.

最好的方法是仅生成N个元素的数组,并做一些数学技巧将输入索引转换为第二个数组的索引.

在这个例子中,将1,5,100,300分别转换为0,1,2,3.我已经能够做一种预处理方法来改造它们,但我正在寻找一种避免这一步骤的方法.

换句话说,我认为我正在寻找某种最小的完美散列,可以在编译时以非常有效的方式用于我的特定情况(理想情况下没有任何开销,例如:goto:MyInstruction).

我不是在寻找使用虚函数,std :: map或复杂操作的替代方法.

请问是否有不清楚的事情.

PS我正在使用C++ 11,但任何想法都是受欢迎的

[编辑]我知道标签是GCC的语言扩展值.有了这些我可能能够实现我的目标,但需要一个便携式解决方案.

我正在尝试使用CRTP,但我很困惑为什么以下代码无法编译.

template<template<class...> class CBase>
struct ComponentX : public CBase<ComponentX>
  {
  // This does NOT compile
  };

template<template<class...> class CBase>
struct ComponentY : public CBase<int>
  {
  // This does compile
  };

您知道在CRTP的情况下模板模板参数是否有一些限制？

让我们假设有N个函数采用不同的输入并返回不同的值:

int h(int);
string g(int);
double f(string);

当然可以这样写:

f(g(h(4)))  

现在假设我想将这些函数f,g,h存储到一种容器中,如:

Container c;
c.add(h);
c.add(g);
c.add(f); 

给定第一个函数的输入(在f的情况下为int)我希望这些函数以顺序方式执行,每个函数都将前一个函数的输出作为输入.

你认为在C++中有可能吗？可能没有使用dynamic_cast和使用C++ 11

我试图理解为什么这段代码不能编译：

// test.h
struct Base
  {
  virtual ~Base{};
  virtual void execute() {}
  virtual void execute(int) {}
  virtual void execute(double) {}
  }

template<class T>
struct Test : Base
  {
    void execute(typename std::enable_if<std::is_void<T>::value, void>::type)
      {
      // Do A
      }

    void execute(typename std::enable_if<!std::is_void<T>::value, int>::type t)
      {
      // Do B
      }
  };

// main.cpp
Test<void> t; 

我收到编译器错误：“没有名为类型的类型”。

即使我修改代码的 A 版本，也会出现同样的错误

std::enable_if<std::is_void<T>::value>

目标是创建一个类，该类根据参数 T 创建不同的函数成员。在本例中是 2，但我也对更多感兴趣。

[编辑]我添加了我在评论中讨论的继承部分。

我一直在玩模板和继承,但是在对基类执行强制转换时,使用带有模板参数的虚函数成员有一些奇怪之处.他们似乎使用"直接继承",但如果我稍后"推迟"继承,则不行.

一些代码来说明:

示例[1]

struct CastExBase
  {
  virtual void f() {}
  };

template<class RT>
struct CastExA : CastExBase
  {
  void f() {std::cout << "CastExA" << std::endl;}
  virtual void g() {std::cout << "g - A" << std::endl;}
  virtual RT h() {std::cout << "h - A" << std::endl;}
  };

struct CastExB
  {
  void execF() {std::cout << "CastExB" << std::endl;}
  void g() {std::cout << "g - B" << std::endl;}
  int h() {std::cout << "h - B" << std::endl;}
  };

struct CastExC :
    public CastExA<int>, …