这是"Tag Dispatching"吗？

Question

说我有一些代码:

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,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>();
}

我在其中介绍了两个空的"Tag"类,以指示bar使用和模板化foo并bar基于标记类.这似乎可以解决问题.问题:

1. 这种技术有名字吗？这是"标签调度"的一个例子吗？从我读到的关于Tag调度的内容来看,它略有不同,并且涉及使用tag参数的函数重载.可能来自特征类中的typedef的标记.
2. 是否有一种更加自觉的编译时技术来实现同样的目的？

编辑: 另一种可能性是使用函数重载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>();
}

Answer 1

这不是标签调度.正如你在你的问题中正确地说的那样,如果你使用了一些编译时特征A并B区分这两者,然后用它来选择两个不同的重载.

标签分派的一个很好的例子std::advance是通常如何实现.函数的签名是

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

itn如果它满足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原则的例子.

如果bar采用了一个实例A并B作为参数,那么我将以不同的方式实现它.我没有制作bar功能模板,而是提供专业化,而是让重载解决方案为我完成工作.

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

但由于情况并非如此,提供明确的专业化似乎是正确的方法.