如果模板化函数存在，如何调用它，否则如何调用其他函数？

Question

我想做一些事情，就像

template <typename T>
void foo(const T& t) {
   IF bar(t) would compile
      bar(t);
   ELSE
      baz(t);
}

我认为使用 enable_if 可以完成这里的工作，将 foo 分成两部分，但我似乎无法弄清楚细节。实现这一目标的最简单方法是什么？

Answer 1

针对名称 bar 进行了两次查找。一种是在 foo 的定义上下文中进行非限定查找。另一种是每个实例化上下文中的参数相关查找（但每个实例化上下文中的查找结果不允许更改两个不同实例化上下文之间的行为）。

为了获得所需的行为，您可以在 fallback 命名空间中定义一个后备函数，该函数返回某种唯一类型。

namespace fallback {
  // sizeof > 1
  struct flag { char c[2]; };
  flag bar(...);
}

如果没有其他匹配，则将调用 bar 函数，因为省略号具有最差的转换成本。现在，通过 fallback 的 using 指令将该候选项包含到您的函数中，以便将 fallback::bar 作为候选项包含到对 bar 的调用中>。

现在，要查看对 bar 的调用是否解析为您的函数，您将调用它，并检查返回类型是否为 flag。否则选择的函数的返回类型可能为 void，因此您必须使用一些逗号运算符技巧来解决这个问题。

namespace fallback {
  int operator,(flag, flag);

  // map everything else to void
  template<typename T> 
  void operator,(flag, T const&);

  // sizeof 1
  char operator,(int, flag);
}

如果选择了我们的函数，则逗号运算符调用将返回对 int 的引用。如果不是或者所选函数返回 void，则调用将依次返回 void。然后，如果选择了后备，则使用 flag 作为第二个参数的下一次调用将返回一个 sizeof 1 的类型，并且 sizeof 大于 1（将使用内置逗号运算符，因为 void 在混合中）如果选择了其他内容。

我们将 sizeof 和 delegate 与结构体进行比较。

template<bool>
struct foo_impl;

/* bar available */
template<>
struct foo_impl<true> {
  template<typename T>
  static void foo(T const &t) {
    bar(t);
  }
};

/* bar not available */
template<>
struct foo_impl<false> {
  template<typename T>
  static void foo(T const&) {
    std::cout << "not available, calling baz...";
  }
};

template <typename T>
void foo(const T& t) {
   using namespace fallback;

   foo_impl<sizeof (fallback::flag(), bar(t), fallback::flag()) != 1>
     ::foo(t);
}

如果现有函数也有省略号，则该解决方案是不明确的。但这似乎不太可能。使用后备进行测试：

struct C { };
int main() {
  // => "not available, calling baz..."
  foo(C());
}

如果使用参数相关查找找到了候选者，

struct C { };
void bar(C) {
  std::cout << "called!";
}
int main() {
  // => "called!"
  foo(C());
}

为了在定义上下文中测试非限定查找，让我们在 foo_impl 和 foo 上面定义以下函数（将 foo_impl模板位于 foo 之上，因此它们具有相同的定义上下文）

void bar(double d) {
  std::cout << "bar(double) called!";
}

// ... foo template ...

int main() {
  // => "bar(double) called!"
  foo(12);
}

Answer 2

litb 有给了你一个很好的答案。然而，我想知道，鉴于更多的背景，我们是否无法想出一些不那么通用，但也更少，嗯，详细的东西？

例如，什么类型可以是T？任何事物？有几种类型？您可以控制的非常有限的集合？您设计的一些类与函数 foo 结合使用？鉴于后者，您可以简单地将类似的内容

typedef boolean<true> has_bar_func;

放入类型中，然后基于此切换到不同的 foo 重载：

template <typename T>
void foo_impl(const T& t, boolean<true> /*has_bar_func*/);
template <typename T>
void foo_impl(const T& t, boolean<false> /*has_bar_func*/);

template <typename T>
void foo(const T& t) {
  foo_impl( t, typename T::has_bar_func() );
}

此外，可以 bar/baz 函数几乎具有任何签名，是否有一组受限制的签名，或者只有一个有效签名？如果是后者，litb 的（优秀的）后备想法与使用 sizeof 的元函数相结合可能会更简单一些。但这我还没有探索过，所以这只是一个想法。

Answer 3

我认为 litb 的解决方案有效，但过于复杂。原因是他引入了一个函数 Fallback::bar(...) ，该函数充当“最后手段的函数”，然后竭尽全力不调用它。为什么？看来我们有一个完美的行为：

namespace fallback {
    template<typename T>
    inline void bar(T const& t, ...)
    {
        baz(t);
    }
}
template<typename T>
void foo(T const& t)
{
    using namespace fallback;
    bar(t);
}

但正如我在 litb 的原始帖子的评论中指出的，有很多原因导致 bar(t) 无法编译，而且我不确定这一点解决方案处理相同的情况。它肯定会在 private bar::bar(T t) 上失败

Answer 4

如果您愿意只使用 Visual C++，则可以使用 __if_exists 和 __if_not_exists 声明。

在紧要关头很方便，但特定于平台。

Answer 5

编辑：我说得太早了！ litb的答案 显示了如何实际完成此操作（可能会损害您的理智......:-P）

不幸的是，我认为检查“是否可以编译”的一般情况超出了 函数模板参数推导+SFIN​​AE，这是这玩意的常用技巧。我认为您能做的最好的事情就是创建一个“备份”函数模板：

template <typename T>
void bar(T t) {   // "Backup" bar() template
    baz(t);
}

然后将 foo() 更改为简单的：

template <typename T>
void foo(const T& t) {
    bar(t);
}

这适用于大多数情况。由于 bar() 模板的参数类型为 T，因此与任何其他名为 bar()< 的函数或函数模板相比，它将被视为“不太专业” /code> 因此将在重载决策期间将优先级让给预先存在的函数或函数模板。除此之外：

• 如果预先存在的 bar() 本身就是一个采用 T 类型的模板参数的函数模板，则会出现歧义，因为两个模板都不比其他的，编译器会抱怨。
• 隐式转换也不起作用，并且会导致难以诊断的问题：假设有一个预先存在的 bar(long) 但 foo(123) 是叫。在这种情况下，编译器会悄悄地选择用 T = int 实例化“备份”bar() 模板，而不是执行 int->long< /code> 促销，即使后者可以编译并正常工作！

简而言之：没有简单、完整的解决方案，而且我很确定甚至没有一个棘手的、完整的解决方案。 :(

Answer 6

//default

////////////////////////////////////////// 
    template <class T>
    void foo(const T& t){
        baz(t);
    }

//specializations
//////////////////////////////////////////  

    template <>
    void foo(const specialization_1& t){
        bar(t);
    }
    ....
    template <>
    void foo(const specialization_n& t){
        bar(t);
    }

Answer 7

您是否无法在 foo.txt 上使用完全专业化（或重载）？比如说有函数模板调用 bar 但对于某些类型完全专门化它来调用 baz？