基类成员访问属性  继承方式  派生类成员访问属性

private成员                                 无法访问

protect成员            public          protected

public成员                                    public

void test1(Person p){p.play}调用test1的时候，因为在test1中所定义的参数是一个对象P，所以传值的时候会先实例化临时对象P，通过临时对象P调用play这个函数，在test1执行完毕之后，p这个临时对象就会被销毁 如果函数的参数是基类的对象，那么基类的对象和派生类的对象，都可以作为实参传递进去，并且可以正常使用。 void test2(Person &p)  没有实例化临时对象，使用基类的引用也可以接收基类的对象以及派生类的对象 void test3(Person *p)的调用结果和void test2(Person &p)一样 因为不产生临时变量，所以void test3(Person *p)、void test2(Person &p)效率更高

<table><tbody><tr class="firstRow"><td><code>Person&nbsp;*p=</code><code>new</code>&nbsp;<code>Soldier;</code><code>//用父类Person的指针指向堆中分配的子类Soldier的对象</code><code>delete</code>&nbsp;<code>p;</code><code>p=NULL;</code><code>//只执行父类的析构函数，而不执行子类的析构函数，可能导致内存泄露</code></td></tr></tbody></table><p>【如何在这种情况下防止内存泄露？】</p><p>虚析构函数：当存在继承关系，且要用一个父类的指针指向堆中子类的对象，并希望用父类的指针释放这块内存时，可以使用。</p><table ><tbody><tr class="firstRow"><td>12345</td><td><code>class</code>&nbsp;<code>Person{</code><code>&nbsp;&nbsp;&nbsp;&nbsp;</code><code>Person();</code><code>&nbsp;&nbsp;&nbsp;&nbsp;</code><code>virtual</code><code>~Person();&nbsp;&nbsp;</code><code>//前面加关键字virtual即可，这个关键字可以被继承下去</code><code>}</code><code>//在Soldier.h中，即使在~Soldier前面不写virtual，也相当于有了这个关键字（被继承下来了）</code></td></tr></tbody></table><p><br/></p>

父类的指针指向子类对象的时候  只能访问子类中父类原有的成员，而无法访问子类中独有的数据成员和成员函数 子类对象向父类对象赋值。或用子类对象初始化父类对象，本质是将子类当中从父类继承下来的数据成员赋值给父类对象，而其他的数据将会被截断，丢失。 父类指针指向子类对象。父类指针只能访问父类原有的成员。

子类和父类的重名函数无法形成重载，只能进行隐藏

遇到一个小问题，在使用#include<string>时，需要配套使用using namespace std;才可正常使用string,否则会出错,也就是string类型应该是在std命名空间。以前一直仅把他当作#include<iostream>使用cout时的命名空间,现在想来应该是同名的命名空间。public Soldier : public Person<br> {<br> }<br> 注意只有一个':',不是两个. 使用string类型必须包含<string> 声明类的最后要加分号. undefined reference问题:一般是少了目标文件 g++ 编译时要加入所有相关的.o文件 include包含头文件时注意双引号“”和尖括号<>是不同的，编译器会搜索不同的路径 （1）尖括号<>是引用C++自身文件库里的头文件，如<iostream> （2）双引号“”则是引用用户自己编写的头文件，如“Person.h”

A类有void ABC（），B类也有void ABC（），B类公有继承A类，基类中的ABC（）成员函数就会被B类中的ABC（）成员函数隐藏，隐藏的特性体现在：当实例化B的对象的时候，使用该对象只能够直接的访问到子类B中的ABC（）成员函数，而无法访问父类中的ABC（）成员函数 从语法的角度来说，同名的数据成员也具有隐藏的特征<br> 父子关系，成员同名，隐藏 对象调用同名的成员函数：直接soldier.play()；调用的是自己的成员函数，如果要调用父类的成员函数，则需要加上父类的类名，soldier.Person::play()

公有继承 class A:public B 保护继承 class A:protected B 私有继承 class A:private B 公有继承时基类中各成员属性保持不变，基类中private成员被隐藏。 派生类的成员只能访问基类中的public/protected成员，不能访问private成员； 派生类的对象只能访问基类中的public成员。 保护继承时基类中各成员属性均变为protected，且基类中private成员被隐藏。派生类的成员只能访问基类中的public/protected成员，不能访问private成员；派生类的对象不能访问基类中的任何的成员。 私有继承时基类中各成员属性均变为private，且基类中private成员被隐藏。派生类的成员也只能访问基类中的public/protected成员，不能访问private成员 派生类的对象不能访问基类中的任何的成员。

①通过public继承的都是被继承为派生类中所对应的访问属性（private例外），

如：基类public通过public继承为派生类中public；

       基类protected通过public继承为派生类中protected‘

       基类private通过public继承为无法访问。

②通过protected继承的都是被继承为派生类中的protected访问属性（private例外），

如：基类public通过通过protected继承为派生类中protected；

       基类protected通过protected继承为派生类中protected；

       基类private通过protected继承为无法访问。

③通过private继承的都是被继承为派生类中的protected访问属性（private例外），

如：基类public通过通过private继承为派生类中private;

       基类protected通过private继承为派生类中private；

       基类private通过private继承为无法访问。

公有成员可以直接访问，可以间接通过自身类的公有函数访问，也可以通过子类的公有函数访问 

保护成员不可以直接访问，可以间接通过自身类的公有函数访问，也可以通过子类的公有函数访问 

私有成员不可以直接访问,可以间接通过自身类的公有函数访问，不可以通过子类的公有函数访问

private不能继承、类外不能访问，protected能继承，类外不能访问，public能继承、类外能访问。总结：权限：类外访问 < 继承 < 类内访问。

基类成员访问属性  继承方式  派生类成员访问属性

private成员                                 无法访问

protect成员            public          protected

public成员                                    public

//声明2个类class Person{    public:        Person();        ~Person();        void eat();        string m_strName;        int m_iAge; };class Worker: public Person{    public:        Worker();        ~Worker();        void work();        int m_iSalary;};//定义2个类Person::Person() {     cout<<"Person()"<<endl; }Person::~Person()  {      cout<<"~Person()"<<endl;     }void eat(){    cout<<"eat()"<<endl;}       //定义worker类的函数 Worker::Worker() {     cout<<"Worker()"<<endl; }    Worker::~Worker()  {   cout<<"~Worker()"<<endl;     }  void work()  {   cout<<"work()"<<endl;  }   //应用  Worker *p = new Worker();  p->m_strName = "jim";  p->m_iAge = 10;  p->eat();  p->m_iSalary =100;  p->work();  delete p;  p = NULL;  //先调用Person,再Worker,析构相反

什么是继承，为什么要继承？

基类----派生类

父类 ----子类

class worker : public person

{

public:

    void work();

    int m_iSalary;

}

//工人类继承了人类，就不需要重新写人类的属性，只写自己的属性；工人类是人类的派生类，人类是工人类的基类；人类是父类，工人是子类。

所以派生类和基类是一起组合，父类和子类是一起组合

多重继承：比如，人类-士兵类-步兵类，

class Person{};

class Soldier:public Person {};

class Infantryman:public Soldier{};

多继承：一个子类，同时有2个父类，或者一个派生类，有2个基类，这此种情况为多继承。

class Worker{};

class Farmer{};

class MigrantWOrker:public Worker, public Farmer{};

父类和子类有同名的成员函数，但有不同的参数，此种情况也形成隐藏