作为函数模板的 T* 参数传递时使用运算符 T* 强制模板类

Question

假设我有一个像这样的函数模板：

template<class T>
inline
void
doStuff(T* arr)
{
  // stuff that needs to use sizeof(T)
}

然后在另一个 .h 文件中，我有一个模板类 Foo ，其中包含：

public: operator T*() const;

现在，我意识到这些是不同的 T。 但是如果我有一个变量 Foo; f 在堆栈上，将其强制为任何类型指针的唯一方法是调用运算符 T*()。 然而，如果调用 doStuff(f)，GCC 会抱怨 doStuff 无法采用 Foo 而不是自动使用运算符 T*() 强制转换为 Bar*，然后将 Bar 的函数模板专门化为 T。

我可以做些什么来使这两个模板一起工作吗？ 或者模板函数的参数必须是真正的指针类型，还是将带有强制运算符的模板类传递给非模板函数？

Answer 1

海湾合作委员会是正确的。 在模板参数中，仅考虑完全匹配，而不考虑类型转换。 这是因为否则可能必须考虑无限（或至少指数）数量的转换。

如果 Foo是您要运行的唯一其他模板，最好的解决方案是添加：

template<typename T> inline void doStuff(const Foo<T>& arr) {
    doStuff(static_cast<T*>(arr));
}

如果您在很多模板中遇到此问题，这个应该可以解决它：

#include <boost/type_traits/is_convertible.hpp>
#include <boost/utility/enable_if.hpp>
template<template <typename> class T, typename U> inline typename boost::enable_if<typename boost::is_convertible<T<U>, U*>::type>::type doStuff(const T<U>& arr) {
    doStuff(static_cast<U*>(arr));
}

不过它有点冗长;-)

Answer 2

这可能值得一试：

doStuff<Bar>(f);

我认为这将导致编译器期望 T* 为 Bar*，然后使用 Foo 的运算符 T*() 来执行转换，但我不能说我已经尝试过。

Answer 3

莱昂的想法可能是最好的。 但在紧要关头，您也可以显式调用强制转换运算符：

doStuff(static_cast<Bar*>(f));

Answer 4

我不确定为什么转换不起作用，但您可以使用重载来解决问题

template 
inline
void 
doStuff(T& arrRef)
{
  doStuff(&arrRef);
}

Answer 5

嗯，T* 并不是您所认为的与 T 不同的类型。 指针是一个类型限定符。 我不确定标准对此有何规定，但我想说，由于变量已经是 T 类型，因此它不会再次尝试转换。 如果您想做一些自定义的事情来获取指针，请重载 & 操作员。