#ifndef _COMPLEX_H_
#define _COMPLEX_H_

#include <iostream>

namespace complex {

class Complex {
  // Style tip: always put your public members before private members.
 public:
  Complex(const double real, const double imag);  // Constructor
  Complex(const double real);                     // overloaded Constructor
  Complex(const Complex& copyme);                 // Copy constructor
  ~Complex();                                     // Destructor

  // Accessors / mutators, defined inline.
  double real() const { return real_; }
  double imag() const { return imag_; }
  void set_real(const double real) { real_ = real; }
  void set_imag(const double imag) { imag_ = imag; }

  // Override the "-", "=", "+=", and "-=" operators.
  // Note that "-", like "+", could have been a non-member
  // function.  That would generally be better style since it can reduce
  // the amount of code with access to private instance data, and allows
  // "-" to treat its operators symmetrically, but we made it a member
  // function here as an example of what is possible.
  // "=", "+=", and "-=" normally should be member functions since
  // they do mutate the object's state instead of producing a new
  // object as a result.
  Complex operator-(const Complex &a) const;
  Complex &operator=(const Complex &a);
  Complex &operator+=(const Complex &a);
  Complex &operator-=(const Complex &a);

  // Overload ">>" for istream.  Note that this is a global
  // function, not a member function of class Complex.  It could
  // have been implemented as an ordinary, non-friend function
  // using the set_real() and set_imag() member functions and that
  // would generally be better style since it reduces the code that
  // has access to private data.  See "<<" for an example of a
  // non-friend stream i/o function.
  friend std::istream &operator>>(std::istream &in, Complex &a);

 private:
  double real_, imag_;  // Member variables.
};  // class Complex

// additional overloaded operators (not member or friend functions)
// (see above notes above about "-" and "<<", which should usually
// be done this way also when possible)

Complex operator+(const Complex &a, const Complex &b);

std::ostream &operator<<(std::ostream &out, const Complex &a);

}  // namespace complex

#endif  // _COMPLEX_H_