2020-5-22；

include

using namespace std;
//.h(header)
/**/

/*
#ifndef COMPLEX//防卫式声明；
#define_COMPLEX_

endif

*/

/**/

/*
模板简介
class complex{
public:
complex(T r=0,T i=0)
:re(r),im(i)
{}
complex& operate+=(const complex)&;
T real() const{return re;}
T imag() const {return im};
private:
T re ,im;
}
*/

/*****/

/*
inline 功能建议编译器把函数生成inline函数，加快速度
inline
complex::complex(const char* cstr=0)
{
if(cstr){
m_data=new char(strlen(cstr)+1);
strcpy(m_data,cstr);
}
else
{
m_data=new char[1];
*m_data='\0';
}
}
*/

/****/

/*
acess level：访问级别
class complex{
public:

complex(double r=0,double i=0)
: re(r),im(i)
{};
complex& operator +=(const complex&);
double real()const {return re;}
double imag()const {return im;}

private:
double re,im;
char* m_data;
friend complex&_doap1(complex*,const complex&);
};
{
complex ca(1,2);
cout<<c1.real();
cout<<c1.imag();

}*/

/****/

/*
构造函数
class complex{
public:
complex(double r=0,double i=0)//函数名称必须和类的名称相同，默认实参，没有返回值
: re(r),im(i)//初值列，初始列
{};//赋值
complex():re(0),im(0){}//与前面的冲突，两者存在其一
complex& operator +=(const complex&);
double real()const {return re;}
double imag()const {return im;}
void real(double r){re=r;}
private:
double re,im;
char* m_data;
friend complex&_doap1(complex*,const complex&);
};
构造函数可以多个重载;
*/

/**/

/*
单列模式singleton，把构造函数写进private;
class A{
public :
static A& getInstance();
setup() {,,}
private:
A();
A(const A& rhs);
...
};
A& A::getInstance()
{
static A,a;
return a;
}
A::getInstance().setup();
*/

/*****/

/*
const（常量成员函数）
class complex{
public:

complex(double r=0,double i=0)
: re(r),im(i)
{};
complex& operator +=(const complex&);
double real()const {return re;}    //const 不改变数据
double imag()const {return im;}

private:
double re,im;
char* m_data;
friend complex&_doap1(complex*,const complex&);
};
{
complex c1(1,2);
cout<<c1.real();
cout<<c1.imag();

}
{
const complex c1(2,1);//此时real()后面必须加const;
cout<<c1.real();
cout<<c1.imag();
}
*/

/****/

/*
参数传递，返回值
class complex{
public:
complex(double r=0,double i=0) //值传递
: re(r),im(i)
{};
complex& operator +=(const complex&); //传递引用，等同于指针
double real()const {return re;}
double imag()const {return im;} //返回值
private:
double re,im;
char* m_data;
friend complex&_doap1(complex*,const complex&); //返回引用
};
{
complex c1(1,2);
complex c2;
c2+=c1;
}
传字符，字符相当于一个字节，而传递引用相当于四个字节，但大体范围内还是传递引用比较快
传引用+const,引用不可以被改变，而没有const将会影响引用
局部变量不可以传引用
*/

/****/

/*
friend(友元)函数
class complex{
public:

complex(double r=0,double i=0)
: re(r),im(i)
{};
complex& operator +=(const complex&);
double real()const {return re;}
double imag()const {return im;}

private:
double re,im;

    friend complex&_doap1(complex*,const complex&);

};
inline complex& //接收端接收引用
_doap1(complex *ths,const complex& r)
{
ths->re+=r.re; //自由取得friend的private成员
ths->im+=r.im;
return *ths;

}

//相同claa的各个objects互为friends(友元)
class complex{
public:
complex(double r=0,double i=0)
:re(r),im(i)
{}
int func(const complex& param) //没有friend修饰,依旧能获得private成员;
{return param.re+param.im;}
private:
double re,im;
};
{
complex c1(2,1);
complex c2;
c2.func(c1);
}
*/

/***/

/*
操作符重载（成员函数）
inline complex&
complex::operator+=(const complex& r)
{
return _doap1(this ,r); //this 隐藏指针
}
例如:c2+=c1; //此时函数类型可以改为void;
c3+=c2+=c1; //此时函数类型必须有返回值
inline complex& //接收端接收引用
_doap1(complex *ths,const complex& r)
{
ths->re+=r.re;
ths->im+=r.im;
return *ths; //返回值，使用者无需知道接收者是以引用形式接受
}

《----------------------------------------------------------------------------》
非成员函数 无this
inline complex //接收端接受值
operator+(const complex& x,const complex& y)
{
return complex(x.real()+y.real(),
x.imag()+y.imag()); //typename();类似于int（）；
}
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));
}
此时不可返回引用，创建临时对象，返回值是个局部变量，局部变量不可以传递引用

/***/