1.派生类不能直接访问基类的私有成员，必须通过基类方法进行。 派生类可以直接访问（调用）基类的公有类方法。

   创造派生类对象时，程序先创建基类对象.  派生类构造函数必须使用基类构造函数。 

class TablePlayer{ //基类声明，在.h文件中
private: 
  string  firstname;
  string lastname;
public:
  TablePlayer(const string & fn="none", const string & ln="none");
  void Name() const;
};
//方法的实现在.cpp文件中
TablePlayer::TablePlayer(const string & fn, const string & ln) : firstname(fn), 
                         lastname(ln) {}   //成员初始化列表法
void TablePlayer::Name() const
{ std::cout<<lastname<<","<<firstname }   
 
class ReatedPlayer: public TablePlayer{ //公有派生类
private:
  unsigned int rating;
public:
  ReatedPlayer(unsigned int r, const string & fn="none",
               const string & ln="none") 
  ReatedPlayer(unsigned int r,const TablePlayer & tp); //
  unsigned int Rating() const {return rating; }
};
//派生类的构造函数
ReatedPlayer::ReatedPlayer(unsigned int r, const string & fn,
        const string & ln) : TablePlayer(fn,ln) //将fn,ln参数从派生类构造函数传递到基类构造函数
{
  rating=r;
}
 
ReatedPlayer::ReatedPlayer(unsigned int r, const string & fn,
        const string & ln) //未调用基类构造函数时，等效于使用默认构造函数  : TablePlayer() 
{
  rating=r;
}
 
 ReatedPlayer::ReatedPlayer(unsigned int r,const TablePlayer & tp)：TablePlayer(tp)
{ 
  rating=r;
}
 ReatedPlayer::ReatedPlayer(unsigned int r,const TablePlayer & tp)：
     TablePlayer(tp),rating(r) {} 
int main (void){
 using std::cout; using std::endl;
 TablePlayer player1("Bob", "Boomede");
 RatedPlayer rplayer1(1140, "Mallay","Duck"); //创建派生类对象
 rplayer1.Name(); //派生类可以直接调用基类的公有类方法
}

2.派生类的对象和地址可以赋给基类引用和指针。 但不能将基类的对象和地址赋给派生类引用和指针

 TablePlayer  & rt=rplayer;   TablePlayer  * pt= & rplayer; （合法）

3. C++的3种继承方式：公有继承 ，保护继承 和 私有继承 。公有继承（is-a 关系 即派生类对象也是一个基类对象）

  继承可以在基类基础上添加属性，但不能删除基类属性。

4. 同一个方法在派生类和基类中的行为不同，即 同一方法的行为随上下文而异，这种行为叫多态。

   实现多态公有继承的两种方法：1） 在派生类中重新定义基类  2）使用虚方法（声明函数时在前面加关键字virtual）具体实现不用加。

 在基类中将派生类会重新定义的方法声明为虚方法. （程序将根据对象类型而不是引用或指针类型来选择方法版本）

方法在基类中被声明为虚函数后，派生类中将自动成为虚函数（也可加virtual指明哪些是虚函数）。

为基类声明一个虚析构函数也是一种惯例。【确保释放派生类对象时，按正确的顺序调用析构函数。 先调用派生类析构函数，再调用基类构造函数】 分析：delete pt ; 释放内存时，先应用派生类默认的析构函数，释放派生类对象内存，再调用基类中的虚析构函数来释放内存。 如果不在基类中声明虚析构函数，直接调用基类的析构函数，将只释放部分内存，不会释放派生类中新的类成员指向的内存。

/*基类Brass公有成员函数ViewAcct声明前无virtual*/
 Brass dom(" Dominic Banker",1121,4182.45);//基类对象
 BrassPlus dot("Doroty Banker",1238,2592.00);//派生类对象
 Brass & b1=dom; 
 Brass & b2=dot; //派生类可以直接赋给基类
 b1.ViewAcct(); // 用Brass::ViewAcct() 
 b2.ViewAcct(); // 用Brass::ViewAcct()
/*基类Brass公有成员函数ViewAcct声明前有virtual*/
 b1.ViewAcct(); // 用Brass::ViewAcct() 
 b2.ViewAcct(); // 用BrassPlus::ViewAcct() 根据对象类型而非引用选择版本

5. 在派生类的成员函数实现中：调用基类公有函数时，可直接调用如 doubal bal=Balance()，若派生类中虚函数ViewAcct()中要调用基类的虚函数ViewAcct(),要用作用域解析符，应写为 Brass::ViewAcc()

6. 可以使用一个数组来表示多种类型的对象，这就是多态性。

Brass * p_client[N]; //Brass[i]指针可以指向Brass对象也可指向BrassPlaus对象

 p_client[i]=new Brass(temp,tempnum,tempbal); 

 p_client[j]=new BrassPlaus(temp,tempnum,tempbal,tmax,trate); //满足不同的条件用相应的赋值语句

多态性由以下代码提供：

for (int i=0;i<N;i++){   p_client[i]->ViewAcct();   }

7.在编译过程中进行联编， 称为静态联编 ； （可以直接确定编译哪个函数）

   编译器必须生成能够在程序运行时选择正确的虚函数代码，称为动态联编。

8. 动态联编可以重新定义类方法， 静态联编效率高。

9.编译器处理虚函数的方法：

   给每个对象添加一个隐藏成员。这个成员保存了一个指向函数地址数组的指针，这种数组称为虚函数表（vtbl:virtual function table,）。虚函数表中存储了为类对象声明的虚函数的地址。 虚函数地址表时一个数组。

【基类对象中隐含一个指针，该指针指向基类中所有虚函数的地址表。派生类对象将隐含一个指向独立地址表的指针。          如果派生类提供了虚函数的新定义，该虚函数表将保存为新的地址，如果派生类没有重新定义虚函数，该vtbl将保存基类函数的原始地址】

（无论类中的虚函数是1个还是10个，只在对象中添加1个地址成员，只是表的大小不同）

10. 友元不能是虚函数 （友元不是类成员，只有成员才能是虚函数）

11.重新定义的继承方法并不是重载。

   重新定义的继承方法，应确保与基类的原型完全相同。但如果有返回类型，返回是基类引用或指针，则在派生类继承方法修改为返回指向派生类的引用或指针。                                                                                                                                         

class Dwelling {  public: virtual Dwelling & build (int n)  } ;                                                                                                         
class Hovel:public Dwelling {  public: virtual Hovel & build (int n) };

如果基类声明被重载，则应在派生类中重新定义所有的重载版本。                                                                                         

   class Dwelling {  
   public: virtual void  showperks ( ) const ;   
   virtual void  showperks (int a ) const ;  
   } ;                                    
   class Hovel:public Dwelling {  
   public: virtual void  showperks ( ) const ;   
   virtual void  showperks (int a ) const ;  
   };

12.  派生类成员可以直接访问基类的保护成员，但不能直接访问基类的私有成员。

       对外部世界来说，保护成员和私有成员类似；对派生类来说，保护成员和公有成员类似；

       对类数据成员最好采用私有访问控制，不要使用保护访问控制；同时通过基类的方法使派生类访问基类数据；

        对于成员函数，保护控制有用，让派生类访问公众不能使用的内部函数

13. 复杂抽象基类(ABC:abstract base class) ：只定义接口，不定义实现。至少使用一个纯虚函数接口，从ABC派生的类将根据派生类的具体特征，使用常规虚函数来实现这种接口。 要成为真正的ABC，必须至少包含一个纯虚函数。 原型中的=0使虚函数成为纯虚函数。

【当N类和M类有一定的共性，但M类不需要完全继承N类的数据和方法时，可以将M和N的共性放到ABC中，然后从ABC中派生出N类和M类。 ABC类指针可以同时管理M类和N类对象】 原型使用=0指出类是一个抽象基类。 C++中允许纯虚函数有定义。

例如： 椭圆和圆两个类， 共同点是中心坐标方法，和移动Move()方法是相同的，但面积Area()是不同的。

           在ABC中不能实现Area()方法。 C++通过用纯虚函数提高未实现的函数，纯虚函数声明的结尾处为=0；

            当类声明中包含纯虚函数时，不应该创建该类的对象。 

//椭圆和圆的ABC类  
class BaseEllipse{   //声明中含有纯虚函数，不能创建BaseEllipse类对象
  private: 
     double x; //椭圆和圆的共性
     double y;
  public:
     BaesEllipse(double x0=0,double y0=0) :x(x0),y(y0){}
     virtual ~BaesEllipse();
     void Move(int nx,ny) { x=nx; y=ny; } //椭圆和圆的共性
     virtual double Area() const=0; //纯虚函数  椭圆和圆的不同     
};

14. 构造函数、析构函数、赋值函数、友元函数不能被继承。

原文链接：https://blog.csdn.net/lvliang2017232003/java/article/details/88804365