c++ - ‘operator>>’ 中 ‘std::cin >>' 的模糊重载

Question

我在尝试为要编译的作业获取一些代码时遇到问题。我研究过类似的问题(即使是那些看起来完全相同的问题)，但没有一个解决方案有效。

我的头文件:'complex.h':

#ifndef COMPLEX_H_INCLUDED
#define COMPLEX_H_INCLUDED
#include <iostream>
#include <cstdlib>

using namespace std;

class Complex
{
public:
    // Consructors:
    Complex();
    Complex(double);
    Complex(double, double);

    // Operational Overloads:
    const bool operator == (const Complex&);
    const Complex operator + (const Complex&);
    const Complex operator + (const double&);
    const Complex operator - (const Complex&);
    const Complex operator - (const double&);
    const Complex operator * (const Complex&);
    const Complex operator * (const double&);
    friend ostream& operator << (ostream&, const Complex&);
    friend istream& operator >> (istream&, Complex&);

private:
    double real;
    double imaginary;
};

#endif // COMPLEX_H_INCLUDED

我的实现代码，'complex.cpp':

#include "complex.h"
#include <iostream>
using namespace std;

/****************************************************************************
 *   Constructor ()                                                         *
 ****************************************************************************/
inline Complex::Complex(){
real = 0;
    imaginary = 0;
}

/****************************************************************************
 *   Constructor (double)                                                   *
 ****************************************************************************/
 inline Complex::Complex(double realPart)
             :real(realPart)
{
    imaginary = 0;
}

/****************************************************************************
 *   Constructor (double, double)                                           *
 ****************************************************************************/
inline Complex::Complex(double realPart, double imaginaryPart)
            :real(realPart), imaginary(imaginaryPart)
{}

/****************************************************************************
 *  Operator '==' -- Compares two Complex objects                           *
 *              Returns:                                                    *
 *                -- True if their real and imaginary values are equal      *
 *                -- False otherwise                                        *
 ****************************************************************************/
inline const bool Complex::operator == (const Complex& rhs)
{
    return ((this->real == rhs.real)  && (this->imaginary == rhs.imaginary));
}

/****************************************************************************
 *  Operator '+' -- Adds two Complex objects                                *
 *              Returns:                                                    *
 *                -- The new Complex object                                 *
 ****************************************************************************/
inline const Complex Complex::operator + (const Complex& rhs)
{
    return (Complex((this->real + rhs.real), (this->imaginary + rhs.imaginary)));
}

/****************************************************************************
 *  Operator '+' -- Adds a real number to the Complex object                *
 *              Returns:                                                    *
 *                -- The new Complex object                                 *
 ****************************************************************************/
inline const Complex Complex::operator+(const double& rhs)
{
    return Complex((this->real + rhs), this->imaginary);
}

/****************************************************************************
 *  Operator '-' -- Subtracts the number of another Complex object          *
 *              Returns:                                                    *
 *                -- The new Complex object                                 *
 ****************************************************************************/
inline const Complex Complex::operator - (const Complex& rhs)
{
    return (Complex((this->real - rhs.real), (this->imaginary - rhs.imaginary)));
}

/****************************************************************************
 *  Operator '-' -- Subtracts a real number from the Complex object         *
 *              Returns:                                                    *
 *                -- The new Complex object                                 *
 ****************************************************************************/
inline const Complex Complex::operator-(const double& rhs)
{
    return Complex((this->real - rhs), this->imaginary);
}

/****************************************************************************
 *  Operator '*' -- Multiplies together two Complex objects                 *
 *              Returns:                                                    *
 *                -- The new Complex object                                 *
 ****************************************************************************/
inline const Complex Complex::operator * (const Complex& rhs)
{
    return (Complex((this->real * rhs.real) - (this->imaginary * rhs.imaginary), (this->real * rhs.imaginary) + (this->imaginary * rhs.real)));
}

/****************************************************************************
 *  Operator '*' -- Mutltiplies the Complex object by a real number         *
 *              Returns:                                                    *
 *                -- The new Complex object                                 *
 ****************************************************************************/
inline const Complex Complex::operator * (const double& rhs)
{
    return Complex((this->real * rhs), (this->imaginary * rhs));
}

/****************************************************************************
 *  Operator '<<' -- Outputs the Complex object in a comprehensive format   *
 *              Returns:                                                    *
 *                -- A reference to the ostream                             *
 ****************************************************************************/
ostream& operator <<(ostream& out, const Complex& comp)
{
    if(comp.real != 0)
    {
        out << comp.real;

        if(comp.imaginary > 0)
            out << " + ";
        else if (comp.imaginary < 0)
            out << " - ";
    }

    if(comp.imaginary != 0)
        out << comp.imaginary << "i";

    return out;
}

/****************************************************************************
 *  Operator '>>' -- Takes in a Complex object from the user                *
 *              Returns:                                                    *
 *                -- A reference to the istream                             *
 ****************************************************************************/
istream& operator >>(istream& in, Complex& comp)
{
    char sign; //Used to store input when looking for mathematical operators
    bool neg = false; //Stores whether or not any input values are <0

    // Checks for a negative value for the real
    sign = std::cin.peek();
    if(sign == '-'){
        neg = true;
        std::cin.ignore(1,'-');
    }

    in >> comp.real;

    //Negates the real value if necessary
    if(neg){
        comp.real = -comp.real;
        neg = false;
    }

    //Looks for the + or - operator, accounting for possible variations in whitespacing and hazardous input.
    do{
        in >> sign;
    }while (sign == ' ');

    if (sign == '-')
        neg = true;
    else if (sign != '+'){
        cout << "You did not properly format the input of a complex number. \nPlease use the format: 'a+bi' where 'a' is the real number, and 'b' is the imaginary number." << endl;
        cout << "The program is currently shutting down.";
        exit(EXIT_FAILURE);
    }

    sign = std::cin.peek();

    while(sign == ' ')
        in >> sign;

    in >> comp.imaginary;

    if(neg)
        comp.imaginary = -comp.imaginary;
}

以及实现 complex.cpp 的最终类:

 #include <iostream>
 #include "complex.cpp"

 using namespace std;

 int main()
 {
     Complex aComplex();

     cout << "Please enter a complex number, in the form of 'a+bi', where 'a' is a real number and 'b' the imaginary number." << endl;
     cin >> aComplex;

     cout << "You entered the value: " << aComplex << endl;

     return 0;
 }

当我尝试构建代码时，出现错误:

.../Complex/main.cpp|12|error: ambiguous overload for ‘operator>>’ in ‘std::cin >> aComplex'`

有人有什么想法吗？ (如果有帮助，我正在使用 Code::Blocks 12.11 和 Ubuntu 13.04。)

Answer 1

问题是 aComplex 被声明为一个函数!您可能打算编写以下内容之一:

Complex aComplex;
Complex bComplex = Complex();
Complex cComplex{};

寻找“most vexing parse”来解释为什么你的 aComplex 是一个函数声明。