流运算符重载问题

Question

我有一个使用运算符重载的类，但有一些警告。

// base.h

class base {
public:
    base();
    base(int n);
    virtual ~base();
    virtual void printBase(std::ofstream & out);
    virtual base & operator =(const base &);
    friend std::ofstream & operator <<(std::ofstream & out, const base &);
private:
       double * coeff;
       int n;
};

// base.cpp

std::ofstream & operator<<(std::ofstream & fout, const base & obj)
{
    for(int i =0; i<(obj.n)-1; i++)
    {
        fout << obj.coeff[i]<<"*x"<<i;
        if(i<obj.n-2)
        {
            fout<<"+";
        }
    }
    fout<<"="<<obj.coeff[(obj.n)-1];
    return fout;
}

void base::printBase(std::ofstream & fout)
{
    for(int i =0; i<n-1; i++)
    {
        fout<<coeff[i]; // warning occurs here!!
        if(i<n-2)
        {
            fout<<"+";
        }
    }
    fout<<"="<<coeff[n-1];
}

警告是：

>

 warning: ISO C++ says that these are ambiguous, even though the worst conversion for
 the first is better than the worst conversion for the second:
    c:\wascana\mingw\bin\../lib/gcc/mingw32/4.5.0/include/c++/bits/ostream.tcc:105:5: note:
 candidate 1: std::basic_ostream<_CharT, _Traits>& std::basic_ostream<_CharT, _Traits>::operator<<(int) [with _CharT = char, _Traits = std::char_traits<char>]
    ..\Hyperplane.cpp:55:17: note: candidate 2: std::ofstream& operator<<(std::ofstream&, const Hyperplane&)

从上面的警告来看，应该是<<的问题。我知道原因，但是我该如何处理这个警告呢？

谢谢你！

Answer 1

问题实际上出在类的构造函数之一上：

base(int n);

这个构造函数就是所谓的转换构造函数。它可用于将 int 转换为 base，因此这是合法的：

base x = 42;

如果您不想允许这种隐式转换，您可以使构造函数 < code>explicit：

explicit base(int n);

---

有趣的问题是“fout << coeff[i]; 中的歧义在哪里？

编译器无法在两个候选函数之间做出决定（或者不应该在两者之间做出决定；你的编译器对你“很好”）：一个是内置的 std::ostream operator<< 重载看起来像这样：

std::ostream& operator<<(std::ostream&, double);

第二个是你的运算符重载，看起来像：

std::ofstream& operator<<(std::ofstream&, const base&);

对于第一个候选者，第一个参数需要派生到基的转换：std::ofstream需要转换为std::ostream 表示要调用的函数，第二个参数是 double，

与第二个参数（第一个参数是 std） 完全匹配。 :ofstream，完全匹配第二个参数需要使用内置的 double 到 int 转换，然后使用转换构造函数从 < 进行转换。代码>int到base。

为了让编译器选择一个候选函数作为正确的调用函数，每个参数必须至少与候选函数的相应参数匹配，并且与任何其他候选函数匹配。

对于这两个候选，第一个参数与第二个候选更好匹配，但第二个参数与第一个候选更好匹配，因此存在歧义。

另一种解决方案是更改重载，使第一个参数与内置候选者的第一个参数匹配：

std::ostream& operator<<(std::ostream&, const base&);