C++面向对象 Week1——Boolan

字数 906阅读 40

C++最大的特点是class的使用,通过创建class的对象对类的成员进行调用。比如一个班级学生的基本情况是个类,包括学生的ID,性别,身高,体重,成绩等,而班级里的每一个学生是一个对象。通过学习复数类进一步认识面向对象编程。

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& _doapl(complex*,const complex&);                                                       };                                                                                                                                            第一步需要在.h文件中对类进行声明,防卫式声明可以避免多次include的情况:                           

#ifndef   _COMPLEX_                                                                                                        #define _COMPLEX_                                                                                                                      ..........                                                                                                                               #endif

(1)访问级别:类的成员的访问级有public,private,protected,三者之间的区别可以参考blog.csdn.net/linraise/article/details/42673353

(2)构造函数:构造函数与类同名,当创建对象时,系统会通过构造函数初始化对象,而不能在函数体中调用构造函数。与普通成员函数不同的是它具有初值化列表(initialization“:”之后用来对数据进行初始化),构造函数可以有多个(overloading 重载),通过参数个数和参数类型来进行区分。例如 complex(double r) 与 complex(double r,double i)是不同的构造函数。                                                                                                                              complex (double r=0,double i=0) : re(r),  im(i)   {}                                                                 complex () : re(0),  im(0)  {}  是两种构造函数,但是对于类的创建:                                      complex c1;                                                                                                                              complex c2();两种方式都没有给参数,与第二种构造函数相符,虽然第一种有参数,但是参数有默认值,不需要创建时赋值,所以依然满c足,所以二者是等价的。构造函数一般在public中,特殊情况会放在private中(singleton)。

(3)常量成员函数:const代表函数不会改变数据                                                                       (4)参数传递与返回值传递:by value vs by reference (const)                                                 传引用比传值的速率快,建议传递参数时by reference。                                                   complex& operator +=(const complex&); 参数与返回值都是by reference。                            

(5)友元(friend):可以自由取得互为友元的private成员                                                   inline complex&                                                                                                                       _doapl (complex*ths,const complex& r)                                                                               {                                                                                                                                               ths->re += r.re;                                                                                                                         ths->im += r.im;                                                                                                                       return *ths;                                                                                                                               }                                                                                                                                              可以看到函数调用了private成员re,im。有趣的是,相同类的对象可以调用其他对象的private成员:                                                                                                                             例如有一个成员函数:                                                                                                             int func(const complex& param)                                                                                          { return param.re + param.im ;}                                                                                              complex c1,c2;                                                                                                                        c2.func(c1);                   相同class的各个objects互为友元        

(6)操作符重载                                                                                                                         inline complex&                                                                                                                     complex::operator += (const complex& r)                                                                           {                                                                                                                                                  return _doapl(this,r);                                                                                                             }                                                                                                                                             c1 +=c2; 其中this为隐藏指针,其只想调用函数的对象。                                                        在_doapl函数中 有一个奇怪的地方,return的类型是value,但是函数的返回类型是引用complex&,因为传递者无需知道接收者是以reference形式接收。对于c1+=c2函数返回类型 似乎并不重要,因为结果保存在c1,但对于c1+=c2+=c3  ,就要考虑返回类型,若果是void,那么c1+=void类型就会出现问题。   

(7)临时对象 temp object      typename();                                                                       inline complex                                                                                                                       operator + (const complex& x, const complex& y)                                                             {                                                                                                                                                 return complex (real (x) + real (y),                                                                                                         imag(x) + imag(y));                                                                                                    }                                                                                                                                             上面的情况不能return by reference,因为返回值必定是local object ,在程序结束时生命周期就结束了。                                                                                                                                                                                                      

推荐阅读更多精彩内容