'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'` 

任何人有什么想法？ （我使用的代码:: Blocks的12.11和使用Ubuntu 13.04，有没有什么帮助。）

Answer 1

的问题是，aComplex被声明为一个功能：如果你想实例化对象的空括号应该被删除！你大概的意思是写下列之一：

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

寻找“最伤脑筋的解析”中获得的，为什么你aComplex是一个函数声明的解释。

Answer 2

Complex aComplex(); 

这不叫的Complex构造函数，它创建了一个函数取零个参数并返回一个对象的人类型Complex。

Complex aComplex;