1.推荐书籍
《EFFECTIVE C++改善55个方法》
《STL源码剖析》
《THE C++ STANDARN LIBRARY 》
《C++ Prinmer》
2.头文件与类声明
（1）
类根据里面是否包含指针，分为object based(面向单一class设计) and object oriented(面对多重class的设计，classes和classes之间的关系）；本课程将分别就两种类型举例，分别写一个complex类（复数），和string类（字符串）。
（2）头文件防卫式声明
防止再次调用头文件的时候，程序重复访问头文件主体
#ifndef __COMPLEX__//第一次没有定义该类型，则定义并访问主体，如果第二次访问，则不需要再访问，可用于所有头文件文件
#define __COMPLEX__
class complex
{
......
}
#endif（3）头文件布局
a. class template(模板)简介（开眼界了）
如果你的类里面的变量类型暂时还没确定，或者说你想随机应变，一会儿是int,下一个又可能是double 等等，可以用模板来泛化定义，使用的时候再定义
template <typename> T
class comples
public:
{
complex (T r=0, T i=0):re(r), im(i){}
}
private:{ T re, im;}
//main.cpp
complex<double > c1(2.2,4.3);
complex<int > c2(1, 3);3.构造函数
（1）inline（内建）函数
定义：在class本体内定义的函数称为inline function(但最后是否真的是内联函数，由编译器决定，我们未知，一般太复杂的函数不会被认定为Inline）
（2）访问级别
private:数据或函数部分，不想让外界看到的数据，封装起来；
public：让外界看到。两者可以在一个类body内多次使用
protected:~
（3）构造函数
a.一旦定义，自动启动;
b.构造函数(其他函数也可以)可以有默认值，如果创建的时候未定义，则用default argument；
c.构造函数不需要返回类型；
d.不带指针的类，多半不需要写析构函数;
e.构造函数（其他函数也可以）常常用overloading(重载)，用于多种初值设定想法;
class complex
{
public:
complex(double r=0, double i=0):re(r), im(i) {}//构造函数独有的初始化写法，更大气，等同于在{}里将传值一一赋给参数。这种赋值效率更高
/*
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;}
private:
double re, im;
friend complex& _doap1 (complex *, const complex &);
};
//main.cpp
{
//新建类的几种类型
complex c1(2,1);
complex c2;
complex *p = new complex(4);
}4.参数传递与返回值
（1）ctors 放在private区
存在这种写法，叫Singleton
(2) 常量成员函数
a. 重要！！！在函数后，对于不会改变数据值的函数要加const。如果不加，遇到以下情况，编译器会报错！
class complex
{
public:
complex(double r=0, double i=0):re(r), im(i) {}
double real() const { return re;}//函数不会改变数据大小，const位置在函数定义后，在大括号前面
double imag() const { return im;}//同上
private:
double re, im;
};
//main.cpp
{
complex c1(2,1);
cout<<c1.real();
cout<<c1.imag();
//使用者如上使用没有问题，但是下列使用则会报错
const complex c1(2,1);
cout<<c1.real();//error!因为使用者想定义一个常量，也就是值不能被改变，但是该句调用时，
//如果原类函数没有加const,那么就说明它可能会改变数据的值，但是我前面又定义了常量，不能改变数据值，
//所以编译器就会报错。解决办法就是在不改变值的函数定义时都加上 const。
cout<<c1.imag();
}
(3)参数传递 ：pass by value vs. pass by reference (to const)
a. 参数传递时，尽量传引用。引用在底部就是一个指针，所以传值很快。良好习惯：所有传值都尽量用引用。
（32位编译器：指针4个字节，字符1个字节，整型4个字节，double 8个字节，float 4个字节）
b.传参数引用的同时，不想自身的值被改变时，加const
class complex
{
public:
//...
complex& operator += (const complex&);//这里的参数传值选择的引用，并且由于不想参数在此函数中
//被改变，所以选择加const.
private:
};
//main.cpp
ostream&
operator <<(ostream& os, const complex& x)//同理，注意第一个参数未加const，原因后续道来
{
return os<<'('<<real(x)<<','<<imag(x)<<')';
}c.return by value vs. return by reference 返回值也尽量传引用
complex& operator += (const complex&); //return by reference
double real() const{ return re; } //return by value
double imag() const{ return im; } // return by value
d.传引用也只是尽量，不一定所有场合都适用，后续会讲。
e.友元。对于其他外界函数，不能调用private成员，但是对于友元函数，就允许用private里的数据
private:
double re, im;
friend complex& _doap1 (complex *, const complex &);//友元函数
};
inline complex&
__doap1 (complex * ths, const complex& r)
{
ths->re += r.re;
ths->im +=r.im;
return *ths;
}f. 相同class的各个objects 互为friends（意思就是类本体里面的函数可以调用private成员，而这样可行的原因就是前面所叙述的那样）
class complex
{
public:
//...
int func(const complex& param)
{ return param.re + param.im; }//该成员可以调用私有变量，是因为其默认为友元函数
private:
double re,im;
};
g. 总结：
数据要放在private里；
参数尽量以reference传；
是否加const; 返回值也尽量以reference传（允许的情况下）；
类的本体里的函数应该加const的要记得加；
构造函数的初始化的专业写法。
h.补充：class body 外的各种定义：什么情况下可以pass by reference 什么情况下可以 return by reference
不能pass by reference 的情况：函数内部会将变量改变，则不加const;函数不改变变量的时候，则加const;
complex & ___doap1(complex* ths， const complex& r)//第一个变量在函数内部会被改变，所以不加const, 第二个不会被改变，所以加const.
{
ths->re +=r.re;
ths->im +=r.im;
return *ths;
}不能return by reference的情况：返回值是在函数内部定义的一个变量则不能，因为该变量会随着函数结束而消失。若返回值是已经存在的，则可以返回引用。
complex& ___doap1(complex* ths， const complex& r)//文件名的 & 表明返回的是引用
{
ths->re +=r.re;
ths->im +=r.im;
return *ths;//因为ths是外部已经存在的变量，所以可以返回引用
//下列情况则不能传引用
/*
complex mm;
mm = ths->re + r.re;
return mm;//mm会随着函数结束而消失，所以不能传引用
*/
}5.操作符重载与临时对象
（1）操作符重载-1，成员函数
a. 比如重载 += 操作符，首先我们要知道所有的成员函数一定带有一个隐藏的参数this, 即指向它本身的一个指针，这个指针在函数定义的时候不能出现，但在函数内部可以直接使用，指向的就是调用该函数的那个变量。如 c2 += c1; 则操作符重载中this 指向c2。
inline complex&
complex::operator += (const complex& r)//重载
{
return __doap1 (this, r);//this 默认指向使用的该符号的变量
}
complex & __doap1(complex* ths， const complex& r)//这个函数也可以直接在上面函数定义，但为防止以后还会继续用，则拎出来单独定义。
{
ths->re +=r.re;
ths->im +=r.im;
return *ths;
}//所有左右形式的符号，都可以这样定义
//main.cpp
complex c1(2,1);
complex c2(2,3);
c2 += c1;//+=操作符需要重载b. 传递者无需知道接受者是以reference形式接受
complex & __doap1(complex* ths， const complex& r)//开头的& 是接受端
{
ths->re +=r.re;
ths->im +=r.im;
return *ths;//可以看到返回的是指针指向的值，但是接收端是返回的引用，但是我们可以不必在意，这样是可行的
}c. 对于c3+=c2+=c1的考量，函数返回不能设为void
complex& __doap1(complex* ths， const complex& r)//开始的complex不能为void,如果只是c1+=c2，这样的操作是可以的，c2的值得到了改变，但是如果c1+=c2+=c3这样的操作就会出错，因为c3和c2加完后没有返回值，无法继续和c1相加。
{
ths->re +=r.re;
ths->im +=r.im;
return *ths;
}e class body之外的各种定义，成员函数（函数前面带类的名称 complex::），全域函数（函数名前面没有类名）
(2)操作符重载-2，非成员函数
a. 为了应对使用者的几种可能做法，对应开发三个函数；
b.再次提醒：以下这些重载函数绝不能return by reference，因为传递的是函数内新建的临时对象；
c.特殊语法（临时对象）： typename( c );内部也可以加减，相当于定义了一个新的该类型变量并赋值。它的生命到下一行就会结束，并且没有名称。
inline complex
operator + (const complex& x, const complex& y)//重载复数加复数
{
return complex (real(x)+real(y),
imag(x)+ imag(y));//临时对象，生命下一行就会结束，但是因为已经将值return，所以可行。
}
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) );//新建临时对象
}
//main.cpp
{
complex c1(2,1);
complex c2;
c2 = c1+c2;//复数加复数
c2=c1+5;//复数加浮点数
c2=7+c1;//浮点数加复数
//......
//临时对象举例
complex();//新建一个值为default value的临时对象，下一行就会消失；
complex(2,1);//新建一个实部为2，虚部为1的临时对象。
}e. 操作符重载 正号、符号；编译器看参数个数来判断是正号还是加号
f. " << "输出符号的重载，只能作为全局函数来定义。"<<"的类型是"ostream"
# include <iostream.h>//该操作符重载必须是全局函数
ostream&//返回不能用void，因为有可能连续调用<<,如式3
operator << (ostream& os, const complex& x)//可以看到第一个参数不加const，因为每传一个值，const的状态就会被改变，所以它不是常量
{
return os<<'('<<real (x) <<','<<imag(x) <<')';
}
//main.cpp
{
complex c1(2,1);//1
cout<<conj(c1);//2
cout<<c1<<conj(c1);//3
}