c++面向对象编程：第一讲

专业的类写法

1. 头文件写法：

#ifndef MY_VECTOE_H
#define MY_VECTOE_H
...
    
    
    
#endif

2. 构造函数采用初值列初始化,同时我们的数据应设置为private权限

class complex{
    complex(double r=0,donble i=0)
        :re(r),im(i){}
    ...
    private: 
      double re,im;
};

3. 将成员函数设置为常量

class complex{
public:    
    complex(double r=0,donble i=0)
        :re(r),im(i){}
   double real()const{return re;};
   double imag()const{return im;};
    private: 
      double re,im;
};
//当我们只是拿数据的时候必须将成员函数设置为常量的，避免类使用者与类设计者之间产生的矛盾
//下面两个代码块展示了类设计者如何与类使用者之间的矛盾
{
    complex c1;
    cout<<c1.real();
    cout<<c2.imag();
}//正确
{
    const complex c2;
    cout<<c2.imag();
    cout<<c2.real();
}//错误
//正如第二个代码块，我们的类使用者认为我们这个对象c2是const,是不能改变的，然而我们调用下面的这两个函数的时候，我们的类设计者没有加const,没有加const的意思是我们的那两个函数返回的值可以改变。这就产生了矛盾。

4. 参数传递与返回值:参数传递与返回值都尽量采用pass by reference而不是pass by value

class complex{
    complex(double r=0,donble i=0)//参数传递：pass by value
        :re(r),im(i){}
    complex& operatoe+=(const complex&);//它的参数传递与返回值都是pass by refernece
    ...
    private: 
      double re,im;
    friend complex& _doapl(complex*,const complex&)
};
ostream&
operator(ostream&os,const complex& x){//第二参数为pass by reference
    return os<<real(x)<<imag(x);
}
//为什么我们要采用引用传递而不是值传递？主要因为考虑效率而言，如果我们传值的话，比如我们传入一个1000字节的值，太大了，但是如果我们只传入引用（相当于指针）只有4个字节，这样在效率上更快一点
//什么时候采用pass by reference to const?第一我们不希望我们传入进去的东西被修改
//什么时候我们返回值不能采用pass by reference?先说结论：如果这个函数返回的对象，是在函数内重新创建一个空间来放置就不能使用pass by reference ,因为函数创建的是一个临时变量，在这个函数结束的时候，会销毁这个对象，你传回的reference将是未知的。正如下面这个函数，因为第一参数是可以修改的，最后返回的数据是占用了第一参数的空间，而不是重新创建的空间。所以可以使用pass by reference.
inline 	complex& -doapl(complex* rhs,const complex& r){
     rhs->re+=r.re;
     rhs->im+=r.im;
     return *rhs;
   
}

5. 相同class的各个objects互为友元

class complex{
    complex(double r=0,donble i=0)
        :re(r),im(i){}
    int func(const complex&paa){
        return paa.re+paa.im;
    }
    ...
    private: 
      double re,im;
};
complex c1(2,1);
complex c2;
c2.func(c1);//成立