这是“标签调度”吗？

假设我有一些代码：

void barA() { }
void barB() { }

void fooA() {
  // Duplicate code...
  barA();
  // More duplicate code...
}

void fooB() {
  // Duplicate code...
  barB();
  // More duplicate code...
}

int main() {
  fooA();
  fooB();
}

我想删除之间的重复代码fooA and fooB我可以使用许多动态技术，例如传递 bool 参数、传递函数指针或虚拟方法，但如果我想要编译时技术，我可以这样做：

struct A { };
struct B { };

template<typename Tag> void bar();
template<> void bar<A>() { }
template<> void bar<B>() { }

template<typename Tag> void foo() {
  // Duplicate code
  bar<Tag>();
  // More duplicate code
}

int main() {
  foo<A>();
  foo<B>();
}

我在其中引入了两个空的“标签”类来指示哪个bar使用和模板foo and bar基于标签类别。这似乎可以解决问题。问题：

1. 这项技术有名字吗？这是“标签调度”的示例吗？从我读到的内容来看标签调度 http://www.boost.org/community/generic_programming.html#tag_dispatching它略有不同，涉及使用标签参数的函数重载。可能来自特征类中的 typedef 的标签。
2. 是否有更理想的编译时技术来实现同样的效果？

Edit:另一种可能性是使用函数重载bar而不是模板专门化并将标签类作为参数传递：

struct A { };
struct B { };

void bar(A) { }
void bar(B) { }

template<typename Tag> void foo() {
  // Duplicate code
  bar(Tag());
  // More duplicate code
}

int main() {
  foo<A>();
  foo<B>();
}

这不是标签调度。正如您在问题中正确所说，如果您使用了某些编译时特征A and B区分两者，然后使用它在两个不同的重载之间进行选择。

标签调度的一个很好的例子是std::advance http://en.cppreference.com/w/cpp/iterator/advance通常被实施。该函数的签名是

template< class InputIt, class Distance >
void advance( InputIt& it, Distance n );

it可以进阶n如果满足 RandomAccessIterator 的要求，则在单个操作中定位。对于较小的迭代器，我们必须前进it循环中。因此，实现可能会执行类似于以下内容的操作：

namespace detail
{
  template<class InputIt, class Distance>
  void advance(InputIt& it, Distance n, std::random_access_iterator_tag) 
  {
    it += n;
  }

  template<class InputIt, class Distance>
  void advance(InputIt& it, Distance n, std::bidirectional_iterator_tag) 
  {
    if(n < 0) {
      while(n++) --it;
    } else {
      while(n--) ++it;
    }
  }

  template<class InputIt, class Distance>
  void advance(InputIt& it, Distance n, std::input_iterator_tag) 
  {
    assert(n >= 0);
    while(n--) ++it;
  }
}

template< class InputIt, class Distance >
void advance( InputIt& it, Distance n )
{
  detail::advance(it, n, 
                  typename std::iterator_traits<InputIt>::iterator_category());
}

我不知道你正在做的事情的具体名称。这只是一个如何遵循的示例DRY https://en.wikipedia.org/wiki/Don%27t_repeat_yourself原则。

If bar举了一个例子A and B作为一个论点，那么我会以不同的方式实现它。而不是制作bar一个函数模板，然后提供专业化，我会让重载解析为我完成这项工作。

void bar(A const&) { ... }
void bar(B const&) { ... }

但由于情况并非如此，因此提供明确的专业化似乎是做到这一点的正确方法。