一 C++的良好的编程习惯(正规、大气)
1.使用防卫式声明
#ifndef _DATE_H
#define _DATE_H
....
#endif

2. 按引用传递(reference)
   complex & operator+=(const complex&)

3. 初始化列表(initialization list)
   complex(double r=0, double i=0):re(r),im(i){}

4. 使用inline函数
   inline complex& _doapl(complex *this, const complex &r){
   this->re+=r.re;
   this->im+=r.im;
   return *this;
   }

5. 函数内部没有修改数据 用const修饰
   double real() const {return re;}
   二 按引用传递和操作符重载剖析

6. pass by reference
   按引用传递时c++的特性，c语言是没有这个功能的。传递by引用，实际内部的处理通过地址。
   传递by值，在传递的时候需要进行值得拷贝，需要开辟新空间，然后拷贝内容，花费的时间比较长。
   而传递by引用实际传递的是指针，是一个地址的传递，所以时间开销很小。
   实验测试

   include<iostream>

include<string>

include<ctime>

using namespace std;

struct student{
string name;
string ID;
student(string sname,string sID) :name(sname),ID(sID){}
};

void pass_by_value_test(student stu){
//stu.ID = "20150131";
//stu.name = "李四";
}

void pass_by_reference_test(student &stu){
//stu.ID = "20150131";
//stu.name = "李四";
}

void pass_by_pointer(student *stu){

}

int main(){
student stu1("张三", "20150130");
long beginTime = clock();//获得开始时间，单位为毫秒
for (int i = 0; i < 10000; i++){
pass_by_value_test(stu1);
}
long endTime = clock();//获得结束时间
cout<< "pass_by_value Time:" << endTime - beginTime << endl;
beginTime = clock();
for (int i = 0; i < 10000; i++){
pass_by_reference_test(stu1);
}
endTime = clock();
cout << "pass_by_reference Time:" << endTime - beginTime << endl;
beginTime = clock();
for (int i = 0; i < 10000; i++){
pass_by_pointer(&stu1);
}
endTime = clock();
cout << "pass_by_pointer Time:" << endTime - beginTime << endl;
cin.get();
cin.get();
return 0;
}

实验结果.jpg

通过实验可以看到，通过按值传递花费的时间比引用大很多，按引用和按指针时间很接近。
2. operator overloading
inline complex& _doapl(complex *this, const complex &r){
this->re+=r.re;
this->im+=r.im;
return *this;
}

    //+=是一个二元操作符，所以操作符两边都有一个操作对象
    //但是我们在定义operator +=操作符时右边只有const complex&r 
   //看起来视乎缺少一个操作对象，实际上缺少的对象是当前这个对象
   //c++提供是用this指针来指向当前对象，所以我们不需要显示传入这个对象
    inline complex& complex::operator +=(const complex& r){
            return _doapl(this,r);
     }