# ifndef  TABLE00_H

 # define TABLE00_H

 # include "string";

 using std::string;

 class  Player

 {

 private:

     string first_name;

     string last_name;

     bool SEAT;

 public:  //注意，这里只是头文件，进行函数声明的地方

     //Player(const string & fn = "none", const string & ln = "none", bool symbol = false);

     Player(const string & fn , const string & ln , bool symbol);

     //注意，在最开始设计类的时候，可能我们并没有注意到 要使用 &引用 和const,使用& 和const的契机是：

       //1 使用& 是因为，初始化类型为 string类型或者c类型字符串，进行这种非基类数据类型复制的时候，都会耗费大量内存和时间，所以采用引用&

       // 2 使用const 的契机： 因为这里采用了引用，这种做法是为了不改变被引用引用的对象。思考将引用符号去掉，是否还有加const的必要性？

     void NameShow()const;

     bool SeatVerify()const;

     //思考：在函数名后面加const，是因为在写函数体之前就想好了函数的功能是否改变成员变量，如果函数的功能不改变成员变量，就添加const,

     //说白了这是一种从顶层到底层的设计，我们明白了函数的功能不改变成员变量，所以为了防止写函数体的过程改变成员变量，我们加了一个const。

     // 一般的 const加在谁的前面。就是用来修饰谁的，加在返回类型前面，就是修饰返回值，加在形参前面，即修饰形参，则加在函数名后面，是修饰函数体的，具体的也就是

     //不改变类对象的成员值。即这种函数称之为常成员函数。

     //思考：当函数代码比较短的时候，可否在头文件直接使用内联函数将函数体键入？

     void SetSeat(bool);

 };

 //以下为共有继承类声明部分

 class RePlayer :public Player

 {

 private:

     unsigned int ratio;

 public:

     RePlayer(unsigned int, const string & fn, const string & ln, bool symbol);

     RePlayer(unsigned int, const Player & np);

     int Ratio() const;

     void InitialRatio(unsigned int);

 };

 # endif

 # include "table00.h"

 # include "iostream"

 using std::string;

 using std::cout;

 using std::endl;

  /*class  Player  //如果在函数体文件再声明class Player则会出现重定义的情况！！！，所以采用这种做法是错误的。

 {

 private:

     string first_name;

     string last_name;

     bool SEAT;

 public:

     Player(const string & fn = "none", const string & ln = "none", bool symbol = false)

     {

         first_name = fn;

         last_name = ln;

         SEAT = symbol;

     }

     void  NameShow()const  //注意在函数体中，这个const也不能丢舎.

     {

         cout << first_name << "," << last_name << endl;

     }

     bool SeatVerify()const

     {

         return SEAT;

     }

     void SetSeat(bool change_seat)

     {

         SEAT = change_seat;

     }

 };*/

 //验证上述写法和下述写法哪个更好。以及对于作用域有没有更好的表示方法。

 //Player::Player(const string & fn = "none", const string & ln = "none", bool symbol = false)

 Player::Player(const string & fn , const string & ln, bool symbol )

 {

     first_name = fn;

     last_name = ln;

     SEAT = symbol;

 }

 void Player:: NameShow()const  //注意在函数体中，这个const也不能丢舎.

 {

     cout << first_name << "," << last_name << endl;

 }

  bool Player:: SeatVerify()const

 {

     return SEAT;

 }

  void Player:: SetSeat(bool change_seat)

 {

     SEAT = change_seat;

 }

 //要认识到面向对象这个词的含义：函数的作用尽管也是为了完成一个功能，但更多的是完成对数据的操作，即我们更关注数据本身

 // 成员函数的本质在于：服务于成员变量（通常情况是这样），所以在进行成员函数设计的时候，我们所关注的重点是：对成员变量进行何种操作，完成何种功能

  //一定要注意主体对象是成员变量。

  RePlayer::RePlayer(unsigned int v, const string & fn, const string & ln, bool symbol) : Player(fn, ln, symbol)

  {

      ratio = v;

     // first_name = fn;    注意，如果我们试图直接访问基类私有变量，是有问题的

     // last_name = ln;     但我们需要在调用继承类构造函数之前，调用基类构造函数。

     // SEAT = symbol;

  }

    //这两条都是继承类构造函数，需要在调用之前调用基类构造函数，因此需要先初始化基类构造函数。

  RePlayer::RePlayer(unsigned int v, const Player & np) : Player(np)

  {                                              //需要注意的是：如果 前面定义 unsigned int v =0;则后面的np也要赋初值

      //注意，这里的写法发生了重定义。

      ratio = v;

      // first_name = fn;    注意，如果我们试图直接访问基类私有变量，是有问题的

      // last_name = ln;     但我们需要在调用继承类构造函数之前，调用基类构造函数。

      // SEAT = symbol;

  }

  int RePlayer:: Ratio()const

  {

      return ratio;

  }

  void RePlayer::InitialRatio(unsigned int initial)

  {

      ratio = initial;

  }

 # include "table00.h"

 # include "iostream"

 using namespace std;

 int main()

 {

     Player player1("jack", "cracy", true);

     player1.NameShow();

     Player player2(player1);

     player2.NameShow();

     RePlayer player3(, "robert", "lin", true);

     player3.NameShow();

     RePlayer player4(,player2);

     player4.NameShow();

     system("pause");

     return ;

 }

 # include "table00.h"

 # include "iostream"

 using namespace std;

 void Show(const Player & );

 int main()

 {

     Player player1("jack", "cracy", true);

     player1.NameShow();

     Player player2(player1);

     player2.NameShow();

     RePlayer player3(, "robert", "lin", true);

     player3.NameShow();

     RePlayer player4(,player2);

     player4.NameShow();

     Player & p = player3;   //我们可以用子类去初始化父类，这是没有问题的，因为子类继承了父类的特性（成员）

     p.NameShow();

     Player* q= & player4;

     q->NameShow(); //注意指针的访问方式和引用访问方式的区别，

                    //引用就相当于是别名，所以引用名就和对象名是等价的，因此可以用.访问，而指针并不等价于别名

                    //指针的访问要采用->。

     Player player("ma", "jack", false);

     //RePlayer & rt = player;//我们不可以用父类来初始化（或者赋值）子类，因为子类具有父类不具备的一些特性（子类新3定义成员），

     //RePlayer * pt = &player;

     Player player5("li", "zhou", false);

     Show(player5);//将基类对象作为实参 传递给 基类引用，可行不报错

     RePlayer player6(, "lin", "wu", true);

     Show(player6);//将继承类对象作为实参 传递给 基类引用，，可行不报错

     player6=player5;//试图用基类对象 赋值 继承类 对象，报错！！！

     player5 = player6;//用继承类对象 赋值 基类 对象，不报错，实际上，这里使用了运算符重载！！！player& operator=(const player & )const;

     Player player7(player5); //用基类对象初始化另一个基类对象，可行

     Player player8(player6);//用 继承类 对象初始化 基类对象，可行。

     RePlayer player9(player6);// 用 继承类 对象 初始化 继承类对象 ，可行！

     RePlayer player9(player5);//用 基类对象 初始化 继承类对象，不可行！！！

     system("pause");

     return ;

 }

 void Show(const Player& rt)

 {

     rt.NameShow();

 }