一、子类的构造、析构、拷贝
1、子类的构造在执行它的构造函数前会根据继承表的顺序执行父类的构造函数。
默认执行父类的无参构造
显示调用有参构造，在子类的构造函数后，初始化列表中显示调用父类的有参构造函数。
2、子类在它的析构执行完后，会根据继承表的顺序，逆顺序执行父类的析构函数。
注意：父类的指针可以指向子类对象，当通过父类指针释放对象时，只会调用父类的析构函数，而这种析构方式有可能造成内存泄漏。
3、当使用子类对象来初始化新的子类对象时，会自动调用子类缺省的拷贝构造函数，并且会先调用父类缺省的拷贝构造函数。
如果子类中实现的拷贝构造，需要显式调用父类拷贝构造，否则就会调用无参构造。
二、私有继承、保护继承
使用 private 方式继承父类，公开的变成私有，其他的不变（有争议），这种继承方式防止父类的成员扩散。
使用 protected 方式继承父类，公开成员在子类中会变成保护的，其他不变，这种继承方式可以有效防止父类的成员扩散。
子类以私有或保护方式继承父类，会禁止向上造型（子类的指针或引用不能隐式转换成父类的指针或引用，要想实现多态只能以公开方式继承父类）。
#include <iostream>
using namespace std;
class Base
{
int a;
public:
int b;
protected:
int c;
};
class A:private Base
{
public:
A(void)
{
// cout << a << " " << b << " " << c << endl;
}
};
class B:public A
{
public:
B(void)
{
cout << a << " " << b << " " << c << endl;
}
};
int main()
{
Base* p = new A;
// A a;
// Base a;
// cout << a.a << " " << a.b << " " << a.c << endl;
}
三、多重继承、钻石继承、虚继承
1、多重载继承
在C++中一个子类可以有多个父类，在继承表中按照顺序继承多个父类中的属性和行为，并按照顺序表，调用父类的构造函数。
按照从低到高的地址顺序排序父类，子类中会标记每个父类存储位置。
当子类指针转换成父类的隐式指针时候，编译器会自动计算父类中的内容在子类中的位置，地址会自动进行偏移计算。
#include <iostream>
#include <stdio.h>
using namespace std;
class A
{
public:
int a;
};
class B
{
public:
int b;
};
class C
{
public:
int c;
};
class Test:public A,public B,public C
{
public:
Test(void)
{
a = 1;
b = 2;
c = 3;
}
};
int main()
{
Test* p = new Test;
A* ap = p;
B* bp = p;
C* cp = p;
printf("%p %p %p p:%p\n",ap,bp,cp,p);
cout << ap->a << " " << bp->b << " " << cp->c << endl;
}
2、名字冲突
如果父类中有同名的成员，可以正常继承，但如果直接使用，会造成歧义，需要 类名::成员名 进行访问。
#include <iostream>
#include <stdio.h>
using namespace std;
class A
{
public:
int num;
};
class B
{
public:
int num;
};
class C
{
public:
int num;
};
class Test:public A,public B,public C
{
public:
Test(void)
{
cout << A::num << endl;
}
};
int main()
{
Test* p = new Test;
}
3、钻石继承
假如有一个类A，类B继承类A，类C也继承类A，类D继承B和C。
一个子类继承多个父类，这些父类有一个共同的祖先，这种继承叫钻石继承。
注意：钻石继承不会导致继承错误，但访问祖先类中的成员时每次需要使用 类名::成员名 ，重点是这种继承会造成冗余。
4、虚继承 virtual
当进行钻石继承时，祖先类中的内容会有冗余，而进行虚继承后，在子类中的内容只会保留一份。
注意：但使用虚继承时，子类中会多了一些内容（指向从祖先类继承来的成员）。
5、构造函数
一旦进行了虚继承祖先类的构造函数只执行一次，由孙子类直接调用，祖先类的有参构造也需要在孙子类中显示调用。
6、拷贝构造
在虚拟继承（钻石）中祖先类拷贝构造也由孙子类直接调用，子类中不再调用祖先类的拷贝构造，在手动实现的拷贝构造时（深拷贝），祖先类中的内容也由孙子类负责拷贝，同理赋值构造也一样。
#include <iostream>
using namespace std;
class A
{
public:
int a;
A(void)
{
cout << "A类的构造函数" << endl;
}
A(int num)
{
cout<<"A有参构造"<<endl;
}
};
class B:virtual public A
{
public:
B(void)
{
cout<<"B的构造"<<endl;
}
};
class C:virtual public A
{
public:
C(void)
{
cout << "C的构造" << endl;
}
};
class D:virtual public B,virtual public C
{
public:
D(void)
{
cout << "D的构造" << endl;
}
};
int main()
{
//A a;
//B b;
//C c;
D d;
// cout <<sizeof(A) <<" "<< sizeof(B) <<" "<<sizeof(C)<<" " <<sizeof(D)<< endl;
// cout << d.B::a << endl;
}
四、虚函数、覆盖、多态
1、虚函数
类的成员函数前加 virtual 这种函数就叫做虚函数。
2、覆盖
子类会覆盖父类的虚函数。
3、多态
当子类覆盖了父类的虚函数时，通过父类指针指向子类对象时，调用虚函数，会根据具体的对象是谁来决定执行谁的函数，这就是多态。
#include <iostream>
#include <stdio.h>
#include <stdlib.h>
using namespace std;
class Base
{
public:
virtual void func(void)
{
cout << "我是Base的func函数"<<endl;
}
};
class A:public Base
{
public:
void func(void)
{
cout<<"我是类A的func函数" << endl;
}
};
class B:public Base
{
public:
void func(void)
{
cout<<"我是类B的func函数" << endl;
}
};
class C:public Base
{
public:
void func(void)
{
cout<<"我是类C的func函数" << endl;
}
};
int main()
{
/*覆盖
A* a = new A;
Base* p = a;
Base* b = new Base;
b->func(); // 并没有消失
a->func(); // 调用子类函数
p->func(); // 如果父类的函数是虚函数，调用子类函数
*/
srand(time(NULL));
// 这就是多态
Base* arr[] = {new A,new B,new C};
arr[rand()%3]->func();
}
五、覆盖和多态的条件
1、覆盖的条件
必须是虚函数
必须是父子类之间
函数签名必须相同（参数列表完全一致，const属性也会影响覆盖的结果）
返回值必须是同类型或父子类（子类的返回值要能向父类隐式转换）
访问属性不会影响覆盖
常函数属性也会影响覆盖
#include <iostream>
#include <stdio.h>
#include <stdlib.h>
using namespace std;
class Base
{
public:
virtual Base* func(void)
//virtual void func(void)
{
cout << "我是Base的func函数"<<endl;
}
};
class A:public Base
{
public:
A* func(void)
//在覆盖版本的函数中，所得到的this指针依然是实际对象地址，依然能够调用子类中的函数。
//void func(int num,char* str)
{
cout<<"我是类A的func函数" << endl;
}
};
int main()
{
A* a = new A;
Base* p = a;
p->func();
}
2、重载、隐藏、覆盖（重写）的区别
重载：同一作用域下的同名函数，函数签名不同（类型、个数、顺序、常函数等），构成重载关系。
覆盖：符合一系列条件。
隐藏：父子类之间的同名成员如果没有形成覆盖，且能通过编译，必定构成隐藏。
3、多态的条件
1.父子类之间有的函数有覆盖关系。
2.父类的指针或引用指向子类的对象。
4、在构造、析构函数中调用虚函数
在父类的构造函数中调用虚函数，此时子类还没有创建完成（回顾构造函数的调用过程），因此只能调用父类的虚函数，而不是覆盖版本的虚函数。
在父类的析构函数中调用虚函数，此时子类已经释放完成，因此只能调用父类的虚函数，而不是覆盖版本的虚函数。
#include <iostream>
#include <stdio.h>
#include <stdlib.h>
using namespace std;
class Base
{
public:
Base(void)
{
func();
}
virtual void func(void)
{
cout << "我是Base的func函数"<<endl;
}
~Base(void)
{
func();
}
};
class A:public Base
{
public:
A(void)
{
func();
}
void func(void)
{
cout<<"我是类A的func函数" << endl;
}
~A(void)
{
func();
}
};
int main()
{
A aa;
// A* a = new A;
// Base* p = a;
// p->func();
}
六、纯虚函数和抽象类
1、纯虚函数
在虚函数的声明的后面添加=0，这种虚函数就叫做纯虚函数，可以不实现，但如果实现必须在类外（只能在父类的构造函数、析构函数中调用）。
virtual 返回值 函数名(参数) = 0;
#include <iostream>
#include <stdio.h>
using namespace std;
class Base
{
public:
Base(void)
{
func();
}
// 纯虚函数
virtual void func(void) = 0;
~Base(void)
{
func();
}
};
class A:public Base
{
public:
void func(void)
{
cout << "我是纯虚函数的覆盖"<<endl;
}
};
void Base::func(void)
{
cout<< "我是虚函数" << endl;
}
int main()
{
A a;
a.func();
//Base b;
//b.func();
}
2、抽象类
成员函数中有纯虚函数，这种类叫抽象类，抽象类不能实例化（不能创建对象）。
抽象类必须被继承且纯虚函数被覆盖后，由子类实例化对象。
如果继承抽象类，但没有覆盖纯虚函数，那么子类也将成为抽象类，不能实例化。
3、纯抽象类
所有成员函数都是纯虚函数，这种只能被继承的类叫纯抽象类。
这种类一般用来设计接口，这种类在子类被替换后不需要修改或少量的修改即可继续使用。
#include <iostream>
using namespace std;
class Base
{
public:
virtual void show(void) = 0;
};
class A:public Base
{
public:
void show(void)
{
cout << "我是类A的show函数" << endl;
}
};
class B:public Base
{
public:
void show(void)
{
cout << "我是类B的show函数" << endl;
}
};
class C:public Base
{
public:
void show(void)
{
cout << "我是类C的show函数" << endl;
}
};
enum ClassType{typeA,typeB,typeC};
// 工厂类模式
Base* creat_object(ClassType type)
{
switch(type)
{
case typeA: return new A;
case typeB: return new B;
case typeC: return new C;
default: return NULL;
}
}
int main()
{
Base* p = creat_object(typeA);
p->show();
}
