知识点总结

第8章 运算符重载

对于运算符的基本概念我们可以将运算符看作是一种特殊的函数
所以可以将运算符看作函数进行重载
操作数是函数的参数，运算结果是函数的返回值
　　重载运算符声明为友元，以便访问私有数据成员
　　运算符重载的实质：运算符重载仅仅提供了一种语法上的方便，是以另外一种方式调用函数。
　　不能滥用运算符重载
　　只有至少一个操作数是用户自定义类型时，才可能调用重载的运算符，只有在能使类的代码更易读、使类对象的操作方式更符合一般习惯时，才重载运算符，运算符重载不会改变内置类型的表达式中运算符的含义。
　　最常用的运算符重载是输入重载与输出重载，以图书馆管理系统为例

 friend ostream&operator<<(ostream&out,Record&obj);
 friend istream&operator>>(istream&in,Record&obj);

ostream&operator<<(ostream&out,Record&obj)
{
     out<<obj.bookIndex<<" ";
     out<<obj.bookName<<" ";
     out<<obj.stuName<<" ";
     out<<obj.stuID<<" ";
     out<<obj.type<<" ";
     out<<obj.opTime<<"   ";
     out<<obj.endTime<<"    ";
     out<<obj.ifback;
     return out;
}
istream&operator>>(istream&in,Record&obj)
{
        in>>obj.bookIndex>>obj.bookName>>obj.stuName>>obj.stuID>>obj.type>>obj.opTime>>obj.endTime>>obj.ifback;
        return in;
/*int mian()
{
    Record record1;
    cin>>record1;
    cout<<record1;
}*/

下面是可以重载的运算符
注意：
1.对于类类型的参数，如果仅仅只是读参数的值，而不改变参数，应该作为const引用来传递
2.普通算术运算符、关系运算符、逻辑运算符都不会改变参数，所以以const引用作为参数传递方式。
3.当运算符函数是类的成员函数时，就将其定义为const成员函数

第9章 组合与继承

**一.**对于组合，在之前的学习中我们便经常使用，虽然并没有详细的学习过关于组合的定义，但是使用还是相当频繁的
组合（包含）：将一个类的对象作为另一个类的成员
例如：

class Engine
{
    public:
     void fire(void){...} 
     void stall(void){...}
};
    class Car {
    public:
     void run() { engine.fire(); } 
     void stop() { engine.stall();}
     private:
     Engine engine; 
};
int main()
 {
      Car benz;  
      benz.run(); 
      benz.stop();
 }

在Car和Engine的组合关系中：引擎是汽车的一部分，对外展现的只是汽车的整体功能
1.对于对象成员的初始化
创建包含对象成员的组合对象时，会执行成员类的构造函数初始化对象成员
成员对象的初始化使用初始化列表语法
当组合对象被撤销时，会执行其析构函数，成员对象的析构函数也会被执行
析构函数的执行次序和构造函数相反
2.复用类：
当一个类的功能与所需类的功能类似，应用组合，提供新接口

//xcircle.h
class XCircle 
{
    public:
    XCircle();    //构造函数
    void Xdraw();   //绘制圆形
    double calc_area();  //计算面积
    double calc_perimeter(); //计算周长
    void zoom(double factor);  //按比例缩放

}

复用Xcircle类的方法：
1.如果可以获得源码，修改其源代码
2.应用组合，重新包装一个类对象，使之用于特定的环境

二. 继承：在已有类的基础上创建新类的过程
1.在C++中，
被继承的已有类称为基类；
继承得到的新类称为派生类；
派生类可以再被继承，这样构成的层次结构称为继承层次
类继承关系的语法形式
2.class 派生类名 : 基类名表
{
数据成员和成员函数声明
};
访问控制 表示派生类对基类的继承方式，使用关键字：
public 公有继承
private 私有继承
protected 保护继承
继承分为三种类型，public，private，protected，最常用的是public，因为public限制较少，功能的实现更加丰富多样。protected用的也比较多，因为protected类型的继承是对于派生类函数可以使用基类成员.

#include<iostream>
using namespace std ;
class A
{ public :
      void  get_XY()   { cout << "Enter two numbers of x, y : " ;  cin >> x >> y ; }
      void  put_XY()    { cout << "x = "<< x << ", y = " << y << '\n' ; }
   protected:    int x, y ;
};
class B : public A
{ public :
      int  get_S() { return s ; };
      void  make_S()  { s = x * y ; };    // 使用基类数据成员x，y
   protected:   int s;
};
class C : public B
{ public : 
      void  get_H()   { cout << "Enter a number of h : " ;  cin >> h ; } 
      int  get_V() { return v ; }
      void  make_V()  { make_S(); v = get_S() * h ; }  // 使用基类成员函数
   protected:    int h, v;
};

该代码就详细表明了B类为派生类，继承了A类，然后C类又作为派生类继承了B类

在继承时还有些注意的规则
1.派生类构造函数和析构函数的使用原则
2.基类的构造函数和析构函数不能被继承
3.如果基类没有定义构造函数或有无参的构造函数， 派生类也可以不用定义构造函数4.
4.如果基类无无参的构造函数，派生类必须定义构造函数
5.如果派生类的基类也是派生类，则每个派生类只负责直接基类的构造
6.派生类是否定义析构函数与所属的基类无关

第10章 继承与多态

一. 简介：多态性（Polymorphism）是指一个名字，多种语义；或界面相同，多种实现。
重载函数是多态性的一种简单形式。
虚函数允许函数调用与函数体的联系在运行时才进行，称为动态联编。
冠以关键字 virtual 的成员函数称为虚函数
基类指针虽然获取派生类对象地址，却只能访问派生类从基类继承的成员

#include<iostream>
using namespace std ;
class  Base
{ public :       Base(char xx)  { x = xx; }
                      void who()  { cout << "Base class: " << x << "\n" ; }
   protected:    char x;
} ;
class  First_d : public  Base
{ public :       First_d(char xx, char yy):Base(xx)  { y = yy; }
                      void who()  { cout << "First derived class: "<< x << ", " << y << "\n" ; }
   protected:    char y;
} ;

对于纯虚函数：
纯虚函数是一种特殊的虚函数，
在许多情况下，在基类中不能对虚函数给出有意义的实现，而把它声明为纯虚函数，它的实现留给该基类的派生类去做。
纯虚函数是一个在基类中说明的虚函数，在基类中没有定义， 要求任何派生类都定义自己的版本
纯虚函数为各派生类提供一个公共界面
纯虚函数说明形式：
virtual 类型 函数名（参数表）= 0 ;
一个具有纯虚函数的基类称为抽象类。
例如：

class  point { /*……*/ } ;
class  shape ；   // 抽象类
{ point  center ;
      ……
  public :
  point  where ( ) { return  center ; }
  void  move ( point p ) {center = p ; draw ( ) ; }
  virtual  void  rotate ( int ) = 0 ;   // 纯虚函数
  virtual  void  draw ( ) = 0 ;   // 纯虚函数
} ;
shape  x ;   // error，抽象类不能建立对象
shape  *p ;  // ok，可以声明抽象类的指针
shape  f ( ) ;  // error, 抽象类不能作为函数返回类型
void  g ( shape ) ;  // error, 抽象类不能作为传值参数类型
shape  & h ( shape &) ; // ok，可以声明抽象类的引用