Die Funktion:

ostream &operator<<( ostream& os, const Complex &val )
{
	os << val._real << "+" << val._image << endl;
	return os;
}

istream &operator>>( istream& is, const Complex &val )
{
	cout << "Real-Teil : ";
	is >> val._real;
	cout << "Imaginärer Teil: ";
	is >> val._image;
	return is;
}

die Klasse mit friend:

class Complex 
{
private:
   double _real;
   double _image;
public:
   Complex operator-() {
      return Complex( -_real, -_image );
   }
   Complex( double val1 = 0.0, double val2 = 0.0 ) {
      _real = val1;
	  _image = val2;
   }
   void print_Complex() {
      cout << _real << "+" << _image << endl;
   }
   friend Complex operator+( Complex v1, Complex v2 );
   Complex operator-( Complex val2 ) const {
      Complex tmp(*this);
	  tmp._real -= val2._real;
	  tmp._image -= val2._image;
	  return tmp;
   }
   friend Complex operator+( double val1, Complex val2 );
   Complex& operator++() {
      _real++;
	  _image++;
	  cout << "Präfix ausgewählt " << endl;
	  return *this;
   }
   Complex& operator++(int) {
      static Complex tmp(*this);
	  _real++;
	  _image++;
	  cout << "Postfix ausgewählt " << endl;
	  return tmp;
   }
      friend ostream &operator<<( ostream& os, const Complex &val );
   friend istream &operator>>( istream& is, const Complex &val );
};

test in int main:

Complex val11;
   cin >> val11;
   cout << val11;

(217) : warning C4717: 'operator>>': Rekursiv für alle Steuerelementpfade. Die Funktion verursacht einen Stapelüberlauf zur Laufzeit.

liegt an der Signatur

istream &operator>>( istream& is, const Complex &val )

das const beim rechten Operanden muss weg - mit dem const ist der rechte Operand in

is >> val._real;

natürlich ebenfalls konstant, damit kommt die normale Überladung mit dem Parameter double& nicht mehr in Frage, wohl aber dein eigener Operator, da ja dank des Konstruktors double in Complex konvertierbar ist.