Ошибка c2433 ostream friend не разрешается для объявлений данных

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

  // Fig. 11.14: Complex.h
 // Complex class definition.
//a) Modify the class to enable input and output of complex numbers via overloaded >> and
//<< operators, respectively (you should remove the print function from the class).
//b) Overload the multiplication operator to enable multiplication of two complex numbers
//as in algebra.
//c) Overload the == and != operators to allow comparisons of complex numbers.
 #ifndef COMPLEX_H
 #define COMPLEX_H

 class Complex
 {

 public:

	 void setReal(double real);
	 void setImag(double imaginary);
	 double getReal() const;
	 double getImag() const;
	 Complex( double = 0.0, double = 0.0 ); // constructor
	 Complex operator+( const Complex & ) const; // addition
	 Complex operator-( const Complex & ) const; // subtraction
	 Complex operator ==(const Complex &); //Comparison
	 Complex operator !=(const Complex &); //Negative Comparison
	 Complex operator *(const Complex &) const; // Multiplication
	 friend ostream & operator << (ostream &output, const Complex &temp);
	 friend istream & operator >> (istream &input, const Complex &temp);


 // output
 private:
 double real; // real part
 double imaginary; // imaginary part
 }; // end class Complex

#endif

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74

// Fig. 11.15: Complex.cpp
// Complex class member-function definitions.
 #include <iostream>
 #include "Complex.h" // Complex class definition
 using namespace std;

 // Constructor
 Complex::Complex( double realPart, double imaginaryPart )
 : real( realPart ),
 imaginary( imaginaryPart )
 {
 // empty body
 } // end Complex constructor

 // addition operator
 Complex Complex::operator+( const Complex &operand2 ) const
 {
 return Complex( real + operand2.real,
 imaginary + operand2.imaginary );
 } // end function operator+

 // subtraction operator
 Complex Complex::operator-( const Complex &operand2 ) const
 {
 return Complex( real - operand2.real,
 imaginary - operand2.imaginary );
 } // end function operator-

 //Multiplication Operator
 Complex Complex::operator*(const Complex & operand2) const
 {
	 return Complex(real * operand2.real, imaginary * operand2.imaginary );
 }

 Complex Complex::operator!=(const Complex & operand2)
 {
	 if(real != operand2.real){
		 real = operand2.real;
	return real;
	 }
 }
 Complex Complex::operator==(const Complex & operand2) 
 {
	  if(real == operand2.real){
		 real = operand2.real;
	return real;
	 }
 }

 	 void Complex::setReal(double realPart){
		real = realPart;
	 }
	 void Complex::setImag(double imaginaryPart){
		imaginary = imaginaryPart;
	 }
	 double Complex::getReal() const{
		 return	real;}

	 double Complex::getImag() const{
		 return	imaginary;}

 // display a Complex object in the form: (a, b)
	ostream & operator << (ostream & output, const Complex &temp){
		output << "" << temp.getReal() << endl;
		output << "" << temp.getImag() << endl;
		return output;
	 }
	istream & operator >> (istream &input, const Complex &temp){
		cout << "";
		input >> temp.getImag() << endl;
		cout <<"";
		input >> temp.getReal() << endl;
	}

1
2
3
4
5
6
7
8
9
10
11
12
13

 #include "Complex.h"
 using namespace std;

 int main()
 {
 Complex x;
 Complex y( 4.3, 8.2 );
 Complex z( 3.3, 1.1 );


 system("PAUSE");
 return 0;
 }

1
2
3
4
5
6
7
8

Complex /*bool*/ Complex::operator==(const Complex & operand2) /*const*/
 {
   if(real == operand2.real){
      real = operand2.real; //¿ah?
      return real;
   }
  //¿else what you return?
}

1
2

	 friend std::ostream & operator << (std::ostream &output, const Complex &temp);
	 friend std::istream & operator >> (std::istream &input, Complex &temp);

1
2
3

double imag;
input >> imag;
temp.setImag(imag);