无法通过 C++ 中的隐式转换找到运算符

Question

在编写一个类以充当堆分配对象的包装器时，我遇到了隐式类型转换的问题，可以简化为这个简单的示例。

在下面的代码中，包装类管理一个堆分配的对象并隐式转换为对该对象的引用。这允许将包装对象作为参数传递给函数 write(...)，因为发生了隐式转换。

但是，当尝试解析对 operator

那么，（1）为什么在这种情况下隐式转换会失败？ （2）它可能与依赖于参数的查找有关吗？ (3) 在没有明确演员表的情况下，有什么办法可以完成这项工作吗？

#include <fstream>

template <typename T>
class wrapper
{
    T* t;
  public:
    explicit wrapper(T * const p) : t(p) { }
    ~wrapper() { delete t; }
    operator T & () const { return *t; }
};

void write(std::ostream& os)
{
    os << "(1) Hello, world!\n";
}

int main()
{
    wrapper<std::ostream> file(new std::ofstream("test.txt"));

    write(file);
    static_cast<std::ostream&>( file ) << "(2) Hello, world!\n";
    // file << "(3) This line doesn't compile!\n";
}

Answer 1

它失败了，因为您尝试解析不存在的 wrapper<T> 类的运算符。如果你想让它在没有演员表的情况下工作，你可以把这样的东西放在一起：

template<typename X> wrapper<T> &operator <<(X &param) const {
    return t << param;
}

不幸的是，我不知道在编译时解决返回类型的方法。幸运的是，在大多数情况下，它与对象的类型相同，包括在本例中为 ostream。

编辑： 根据 dash-tom-bang 的建议修改了代码。将返回类型更改为wrapper<T> &。

Answer 2

编译器没有足够的上下文来确定operator& 将进行有效的转换。所以，是的，我认为这与依赖于参数的查找有关：编译器正在寻找一个可以接受非const wrapper<std::ostream> 作为其第一个参数的operator<<。

Answer 3

我认为问题与维护一些编译时约束有关。在您的示例中，编译器首先必须找到 all 可能的运算符

这个测试可能非常复杂，我认为这仅限于提供合理的编译时间。

Answer 4

经过一些测试，一个更简单的示例确定了问题的根源。编译器无法从wrapper<bar<int> > 到bar<int>& 的隐式转换推导出下面f2(const bar<T>&) 中的模板参数T。

template <typename T>
class wrapper
{
    T* t;
  public:
    explicit wrapper(T * const p) : t(p) { }
    ~wrapper() { delete t; }
    operator T & () const { return *t; }
};

class foo { };

template <typename T> class bar { };

void f1(const foo& s) { }
template <typename T> void f2(const bar<T>& s) { }
void f3(const bar<int>& s) { }

int main()
{
    wrapper<foo> s1(new foo());
    f1(s1);

    wrapper<bar<int> > s2(new bar<int>());
    //f2(s2); // FAILS
    f2<int>(s2); // OK
    f3(s2);
}

在原始示例中，std::ostream 实际上是模板化类std::basic_ostream<..> 的typedef，调用模板化函数operator<< 时也是如此。

Answer 5

检查插入运算符的签名...我认为它们采用非常量 ostream 引用？

已确认符合 C++03 标准，char* 输出操作符的签名为：

template<class charT, class traits>
basic_ostream<charT,traits>& operator<<(basic_ostream<charT,traits>&, const charT*);

确实采用了非常量引用。所以你的转换运算符不匹配。

如评论中所述：这无关紧要。

标准中有关于应用转换的各种限制...也许这需要隐式转换（您的运算符，并转换为基本类型），而最多应该应用一个。