【瞎学c++（1）】不带指针的class

#ifndef __COMPLEX__
#define __COMPLEX__ //防止二次include，非常必要
#include <iostream>
using namespace std;
//template <typename T>//不用指定数据类型，使用时再指定，非常必要 
class complex{
	private:
		double re,im;
	public:
		/*构造函数：（注意带指针的要有析构函数） 
			1、名称必须和类名相同。
			2、可以拥有参数。
			3、可以有默认参数。
			4、没有返回值类型。
			5、可以写{re=r;im=i;}
			6、正规写法[	: re(r), im(i)    ]这种写法表示初始化，而非赋值 ，效率更高
			7、写法，冒号后跟内容，常见就是初始化
			8、构造函数可以有很多个（重载） ，在编译器中其实不同名 
			9、重载注意不能符合多个调用条件，如一个有默认参数，一个没有任何参数 
		*/	 
		complex (double r=0, double i=0)  : re(r), im(i) { }
		//{re=r;im=i};上面两行相当于本行，但不同 
		
		//const 如果函数不会改变数据，马上加上const 
		double real() const {return re;}
		double imag() const {return im;}
		
		/*参数传递(pass by reference):
			由于pass by value会把整个变量传递
			传递变量有时过大
			因此尽量使用引用传递（甚至所有） 
			指针会改变值，如果不想被改变，注意const！！！ 
		*/ 
		complex& operator += (const complex&);
		
		/*返回值传递：
			在允许的情况下用reference返回 
			如果return的对象有生命周期，则不能用ref返回 
		*/
		
	//private的内容可以让friend随便使用，效率高但是影响封装
	//同一个class中的object互为friend 
	friend complex& __doapl(complex*, const complex&);
}; 

//操作符重载：重新定义操作符的功能
//成员函数，所有的成员函数都隐藏了this表示调用者，如c2 += c1; 
//下面的非成员也可以写成成员，注意不同之处 
//不可以写在形参里但是可以在函数里用 
//传递者无需知道接受者用引用接受或者值接受 
inline complex& 
__doapl(complex* ths, const complex& r){
	ths->re += r.re;
	ths->im += r.im;
	return *ths;
}
inline complex& 
complex::operator += (const complex& r){
	return __doapl(this,r);
}

inline double
imag(const complex& x){
	return x.imag();
}
inline double
real(const complex& x){
	return x.real();
}
 
 
//非成员函数，没有this，未在class里出现，全局。 
/*c3=c1+c2;
c3=6+c1;
c3=c2+7;*/
//绝对不能return by reference，因为是local object 
inline complex
operator + (const complex& x,const complex& y){
	return complex (real(x)+real(y),imag(x)+imag(y));
}
//注意：complex()创建了临时对象，相当于int()，无名称，生命周期短 
//cout<<complex(2); 
inline complex
operator + (const complex& x,double y){
	return complex (real(x)+y,imag(x));
}
inline complex
operator + (double x,const complex& y){
	return complex (x+real(y),imag(y));
}
inline complex
operator + (const complex& x){
	return x;
}
inline complex
operator - (const complex& x){
	return complex (-real(x),-imag(x));
}

inline bool
operator == (const complex& x,const complex& y){
	return real(x)==real(y)&&imag(x)==imag(y);
}
inline bool
operator == (const complex& x,double y){
	return real(x)==y&&imag(x)==0;
}
inline bool
operator == (double x,const complex& y){
	return real(y)==x&&imag(y)==0;
}
inline bool
operator != (const complex& x,const complex& y){
	return real(x)!=real(y)||imag(x)!=imag(y);
}
inline bool
operator != (const complex& x,double y){
	return real(x)!=y||imag(x)!=0;
}
inline bool
operator != (double x,const complex& y){
	return real(y)!=x||imag(y)!=0;
}
//如果要cout<<conj(c1);编译器就不认识complex怎么输出 
inline complex
conj (const complex& x){
	return complex(real(x),-imag(x));
}

//添加新的输出方式，重载让<<认识complex 
//os不能const，因为他一直在变化 
//注意ostream需要std，返回值最好别void防止cout<<c1<<c2; 
ostream&
operator << (ostream& os,const complex& x){
	return os << '(' << real(x) << ','
			  <<imag(x) << ')';
} 
#endif