//public继承的性质
＃i nclude <iostream>
＃i nclude <string>
using namespace std;

class base
{
public:
 base()
 {
  cout<<"base"<<endl;
 }
 ~base()
 {
  cout<<"~base"<<endl;
 }

};

//注意public继承的用法
class D:public base
{
public:
 D()
 {
  cout<<"D"<<endl;
 }
 ~D()
 {
  cout<<"~D"<<endl;
 }
};

int main()
{
 D d;
 return 0;
}
//子类对象创建时,首先调用父类构造函数,同理析构函数
=========
//public继承的性质
＃i nclude <iostream>
＃i nclude <string>
using namespace std;

class base
{
public:
 base()
 {
  int c;
 a=0;b=1;c=2;
 }
//父类的公有成员
public:
 int a;
 void _a()
 {
  cout<<a<<endl;
 }
//父类的保护成员
protected:
 int b;
 void _b()
 {
  cout<<b<<endl;
 }
//父类的私有成员
private:
 int c;
 void _c()
 {
  cout<<c<<endl;
 }
};

class D:public base
{
public:
 void test() //疑问?为什么实际执行没有进到这里呢?
 {
  a++;
  _a();

  b++;
  _b();

  //下面代码错误,因为私有被隐藏
  //c++;
  //_c();
 }
};

int main()
{
 D d;
 //允许,父类公有子类也公有
 d.a++;
 d._a();
 d.test();

 //不允许,public继承下,父保护子类也保护
 //d.b++;
 //d._b();

 //不允许,隐藏
 //d.c++;
 //d._c();
 return 0;
}
============
//子类成员对父类成员的重定义
＃i nclude <iostream>
＃i nclude <string>
using namespace std;

class base
{
public:
 base()
 {
  a=8;
 }
//父类的公有成员
public:
 int a;
 void _a()
 {
  cout<<a<<endl;
 }

};

class D:public base
{
public:
 D(){a=100;}
 void test()
 {
  //输出D::a
  cout<<a<<endl;
  //调用父类base::_a()
  base::_a();
 }
 //重定义了父类的_a(),但不影响父类的成员函数
 void _a()
 {
  //输入的是D::a,因为成员a被重定义了
  cout<<a<<endl;
 }
public:
 //重定义了父类的成员a
 int a;
};

int main()
{
 D d;

 //输出的是D::a,而不是base::a
 cout<<d.a<<endl;
 //输出base::a
 cout<<d.base::a<<endl;

 //调用D:_a
 d._a();
 //调用base::_a
 d.base::_a();

 d.test();

 base* pBase=&d;
 //父类的a和_a()虽然在D中被重定义,但父类base没有改变,因此调用base::_a()
 pBase->_a();
 return 0;
}
======
//virtual关键字和虚函数,virtual关键字用于修饰类的非静态成员函数,实现面向对象中的多态性,一种形式,多种行为.
//其实是这样的树形父子关系
//base b
//-D1 d1
//   -D1D d1d
//-D2 d2
*//
＃i nclude <iostream>
＃i nclude <string>
using namespace std;

class base
{
public:
 int a;
 virtual void print()
 {
  cout<<"base"<<endl;
 }
};

class D1:public base
{
public:
 void print()
 {
  cout<<"D1"<<endl;
 }
};

class D2:public base
{
public:
 void print()
 {
  cout<<"D2"<<endl;
 }
};

class D1D:public D1
{
public:
 void print()
 {
  cout<<"D1D"<<endl;
 }
};

int main()
{
 base b;
 D1 d1;
 D2 d2;
 D1D d1d;

 b.print();
 d1.print();
 d2.print();
 d1d.print();

 base* pBase=&d1; //d1 is base
 pBase->print(); //多态性,虽然d1是base,但输入却是d1的内容.

 pBase=&d2;
 pBase->print();

 pBase=&d1d;
 pBase->print();

 b=(base)d1d; //这样做不能体现多态的形式
 b.print(); //调用的是base::print()

 return 0;
}

=============
//人person-男人/女人man/woman-张三/李四
＃i nclude <iostream>
＃i nclude <string>
using namespace std;

class person
{
public:
 //每个人都有姓名,所以构造要对姓名初始化
 person(string str)
 {
  name=str;
 }
 //姓名的输入是人的基本属性,所以要在父类中体现
 void print_name()
 {
  cout<<name<<endl;
 }
private:
 string name;
};

class man:public person
{
public:
 man(string str):person(str)
 {

 }//void print_name();
};

class woman:public person
{
public:
 woman(string str):person(str)
 {

 }//void print_name();
};

int main()
{
 man zhangsan("张三");
 man lisi("李四");
 person* pPerson[1]={&zhangsan,&lisi};

 for(int i=0;i<2;i++)
 {
  pPerson[i]->print_name();
 }
 return 0;
}
============
//人person-男人/女人man/woman-张三/李四
＃i nclude <iostream>
＃i nclude <string>
using namespace std;

class person
{
public:
 //每个人都有姓名,所以构造要对姓名初始化
 person(string str)
 {
  name=str;
 }
 //姓名的输入是人的基本属性,所以要在父类中体现
 virtual void print_name()
 {
  cout<<name<<endl;
 }
private:
 string name;
};

class man:public person
{
public:
 man(string str):person(str)
 {

 }
 void print_name()
 {
  cout<<"英俊的";
  person::print_name();
 }
};

class woman:public person
{
public:
 woman(string str):person(str)
 {

 }
 void print_name()
 {
  cout<<"美丽的";
  person::print_name();
 }
};

int main()
{
 man zhangsan("张三");
 woman lisi("李四");
 person* pPerson[2]={&zhangsan,&lisi};

 for(int i=0;i<2;i++)
 {
  pPerson[i]->print_name();
 }
 return 0;
}
================
//纯虚函数
＃i nclude <iostream>
＃i nclude <string>
using namespace std;

class person
{
public:
 //每个人都有姓名,所以构造要对姓名初始化
 person(string str)
 {
  name=str;
 }
 //姓名的输入是人的基本属性,所以要在父类中体现
 //如果原方法调用person zhanger("张尔")或zhanger.print_name();，就只能简单输出姓名。
 virtual void print_name()=0; //纯虚函数可解决这一问题。
protected: //修改为保护级别，使其子类可以被成员函数访问
 string name;
};

class man:public person
{
public:
 man(string str):person(str)
 {

 }
 void print_name()
 {
  cout<<"英俊的"<<name<<endl;
 }
};

class woman:public person
{
public:
 woman(string str):person(str)
 {

 }
 void print_name()
 {
  cout<<"美丽的"<<name<<endl;
 }
};

int main()
{
 //不能定义person类对象
 //person p;
 man zhangsan("张三");
 woman lisi("李四");
 //person zhanger("张尔");
 person* pPerson[2]={&zhangsan,&lisi};

 for(int i=0;i<2;i++)
 {
  pPerson[i]->print_name();
 }
 return 0;
}
============
//proteced继承的性质
＃i nclude <iostream>
＃i nclude <string>
using namespace std;

class base
{
public:
 base()
 {
 a=0;b=1;c=2;
 }
//父类的公有成员
public:
 int a;
 void _a()
 {
  cout<<a<<endl;
 }
//父类的保护成员
protected:
 int b;
 void _b()
 {
  cout<<b<<endl;
 }
//父类的私有成员
private:
 int c;
 void _c()
 {
  cout<<c<<endl;
 }
};

class D:protected base
{
public:
 void test() //疑问?为什么实际执行没有进到这里呢?
 {
  a++;
  _a();

  b++;
  _b();

  //下面代码错误,因为私有被隐藏
  //c++;
  //_c();
 }
};

int main()
{
 D d;
 //不允许,protected下父类公有子类保护
 //d.a++;
 //d._a();
 d.test();

 //不允许,public继承下,父保护子类也保护
 //d.b++;
 //d._b();
 
 //不允许,隐藏
 //d.c++;
 //d._c();
 return 0;
}
=========
//析构函数是否可以定义为虚函数?可以,但是会出现子类被对象销毁时其本身的析构函数可能没有被调用
//只是调用了父类的析构函数,容易引出一些问题.
＃i nclude <iostream>
＃i nclude <string>
using namespace std;

class base
{
public:
 base()
 {
  cout<<"base"<<endl;
 }
 ~base()
 {
  cout<<"~base"<<endl;
 }

};

class D:public base
{
public:
 D()
 {
  cout<<"D"<<endl;
 }
 ~D()
 {
  cout<<"~D"<<endl;
 }
};

int main()
{
 D* pD=new D();
 //下面的操作是安全的,父类析构
 delete pD;

 pD=new D();
 //下面出会出问题,只调父类析构,而子类不
 base* pBase=pD;
 delete pBase;
 return 0;

}