1.析构函数不继承；派生类对象在析构时，基类析构函数的调用顺序与构造函数相反。
注：派生类对象建立时要调用基类构造函数，派生类对象删除时要调用基类析构，顺序与构造函数严格相反。
2.例子
example 1
#include <iostream.h>
#include <math.h>
class Point
{
public:
Point(double a, double b, doule c)
{
x = a;
y = b;
z = c;
}
double Getx() {return x;}
double Gety() {return y;}
double Getz() {return z;}
private:
double x, y;
double z;
};
class Line:public Point
{
public:
Line(double a, double b, double c, double d):Point(a, b, c)
{k = d;}
void show()
{
cout<<Getx()<<endl;
cout<<Gety()<<endl;
cout<<Getz()<<endl;
}
private:
double k;
};
int main()
{
line obj(1.2, 3.4, 5.6, 7.8);
obj.show();
}
问题：class Line:public Point中的public可否换成protected？
答：可以，因为公有继承和保护继承，基类中的公有或者受保护成员在派生类中都可以被访问。
example 2
class Point
{
public:
Point(int i = 0, int j = 0) {x = i; y = j;}
void move(int xoff, int yoff) {x += xoff; yf += yoff;}
int Getx() {return x;}
int Gety() {return y;}
private:
int x, y;
};
class Rectangle:private Point
{
public:
Rectangle(int x, int y, int w, int h):Point(x, y)
{
W = w;
H = h;
}
void move(int xoff, int yoff)
{
Point::move(int xoff, int yoff);
}
int Getx() {return Point::Getx();}
int Gety() {return Point::Gety();}
int GetW() {return W;}
int GetH() {return H;}
private:
int W, H;
};
int main()
{
Rectangle Rect(1, 2, 3, 4);
Rect.move(5, 6);
cout<<"The data of Rect(x, y, W, H):("<<Rect.Getx()<<", "<<Rect.Gety()<<", "<<Rect.GetW()<<", "<<Rect.GetH()<<endl;
}
注：无论该题目的继承方式为public还是protected，调用的Rect.move都是派生类中的move函数（优先派生类）。调用顺序是：
基类-->基类；派生类-->派生类(若无)-->基类。
3.继承的支配规则
基类无法访问派生类的成员。派生类对象或成员也可以引用基类同名成员，这时候需要加上基类的类名作用域。
派生类对象调用：派生类对象.基类名::成员函数()
派生类成员调用：基类名::成员函数
4.例子
example 1
#include <iostream.h>
class Base
{
public:
void f1() {}
void f3() {}
};
class devived:public Base
{
public:
void f1() {}
void f2() {}
};
int main()
{
Base B1, *pb1;
devived d1, *pd1;
pb1 = &B1;
pd1 = &d1;
B1.f1(); //访问基类的f1()
pb1->f1(); //访问基类中的f1()
d1.f1(); //访问派生类中的f1()
pd1.f1(); //访问派生类中的f1()
pb1->f2(); //访问错误，没有这个成员
d1.Base::f1(); //访问基类的f1()
pd1->Base::f1(); //访问基类的f1()
d1.f3(); //访问基类中的f3()
pd1->f3(); //访问基类中的f3()
}
注：派生类对象在引用基类的同名成员时，必须加类的作用域（因为同名成员会优先派生类成员）。
在派生类f2()中访问派生类的f1()：
f2() {f1()} //直接访问即可
在派生类f2()中访问基类的f1()：
f2() {Base::f1()}
修改：pb1 = &d1; pb1->f1(); //访问的是基类中的f1()，因为虽然给基类的指针赋值了派生类的值，但是所指部分仍然只有派生类中继承来的基类的部分。
example 2
#include <iostream.h>
class X
{
public:
int a;
};
class Y1:public X
{};
class Y2:protected X
{};
class Y3:private X
{
private:
void f(Y1 *py1, Y2 *py2, Y3 *py3);
};
class Z:private Y2
{
private:
void f(Y1 *py1, Y2 *py2, Y3 *py3);
};
void f(Y1 *py1, Y2 *py2, Y3 *py3)
{
py1->a = 7; //Y
py2->a = 7; //N：类外不可以访问类内的受保护成员
py3->a = 7; //N：类外不可以访问类内的私有成员（私有继承过来的，类内也不可直接访问）
}
void Y3::f(Y1 *py1, Y2 *py2, Y3 *py3)
{
py1->a = 7; //Y
py2->a = 7; //N
py3->a = 7; //Y，基类中的公有a被继承为私有，类内部可以访问
}
void Z::f(Y1 *py1, Y2 *py2, Y3 *py3)
{
py1->a = 7; //Y
py2->a = 7; //N，该指针指向的是Y2，并非Z
py3->a = 7; //N
}
注：友元函数与类无是一个普通函数，所以友元函数不会继承。
C++语言笔记系列之十四——继承后的访问权限