董家会,萌学园7最终圣战,雷俊聪
继承：
派生类：
程序猿种类有很多种，如 c/c++ 程序猿，java 程序猿，python 程序猿等等。那么我们要把程序猿设计成一个基类， 我们则需要抽出其特有的属性和方法。
所有程序猿的共同属性（成员变量）：
所有的程序猿都有的共同方法（成员函数）：
而不同的程序猿，又有各自不同的属性和方法：
继承的格式如下：
我要评论class 派生类名：public 基类名
{
};
程序猿 coder 基类：
class coder
{
public:
bool isworkovertime(){} // 是否要加班
bool isreward(){} // 是否有奖励
void set(const string & name) // 设置名字
{
m_name = name;
}
...
private:
string m_name; // 姓名
string m_post; // 职位
int m_sex; // 性别
};
python 程序猿 pythoncoder 派生类：
class pythoncoder : public coder
{
public:
bool isaifield(){} // 是否是人工智能领域
bool isbigdatafield(){} // 是否是大数据领域
};
派生类对象的大小 = 基类对象成员变量的大小 + 派生类对象自己的成员变量的大小。在派生类对象中，包含着基类对象，而且基类对象的存储位置位于派生类对象新增的成员变量之前，相当于基类对象是头部。
class cbase
{
int a1;
int a2;
};
class cderived : public cbase
{
int a3;
};
继承的关系是「是」的关系：
继承的关系是「有」的关系：
假设已经存在了 man 类表示男人，后面需要些一个 women 类来表示女人。man 类和 women 类确实是有共同之处，那么就让 women 类继承 man 类，是否合适？
我们先想想继承的逻辑要求，假设 women 类继承 man 类后的逻辑就是：一个女人也是一个男人。很明显，这显然不成立！
所以，好的做法是概括男人和女人的共同特点，抽象出一个 human 类表示人，然后 man 和 woman 都继承 human 类。
假设要写一个小区养狗管理系统：
假定狗只有一个主人，但是一个主人可以最多有 10 条狗，应该如何设计和使用「主人」类 和「狗」类呢？我们先看看下面几个例子：
class cdog;
class cmaster // 主人类
{
cdog dogs[10]; // 狗类的成员对象数组
};
class cdog // 狗类
{
cmaster m; // 主人类的成员对象
};
例子一可以发现是：
相当于人中有狗，狗中有人：
这样是不好的，因为会产生循环不断的构造，主人类构造狗对象，狗类又构造主人对象....
class cdog;
class cmaster // 主人类
{
cdog * pdogs[10]; // 狗类的对象指针数组
};
class cdog // 狗类
{
cmaster m; // 主人类的成员对象
};
这样又变成狗中有人，人去指向「狗中有人」的狗，关系就会显得很错乱，如下图：
class cdog;
class cmaster // 主人类
{
cdog dogs[10]; // 狗类的对象数组
};
class cdog // 狗类
{
cmaster * pm; // 主人类的对象指针
};
这样就会变成，人中有狗，人里面的狗又会指向主人，虽然关系相对好了一点，但是同样还是会绕晕，效果如下图：
class cdog;
class cmaster // 主人类
{
cdog * pdogs[10]; // 狗类的对象指针数组
};
class cdog // 狗类
{
cmaster * pm; // 主人类的对象指针
};
这个是正确的例子，因为相当于人和主人是独立的，然后通过指针的作用，使得狗是可以指向一个主人，主人也可以同时指向属于自己的 10 个狗，这样会更灵活。
如果不用指针对象，生成 a 对象的同时也会构造 b 对象。用指针就不会这样，效率和内存都是有好处的。
比如：
class car
{
engine engine; // 成员对象
wing * wing; // 成员指针对象
};
定义一辆汽车，所有的汽车都有 engine，但不一定都有 wing
这样对于没有 wing 的汽车，wing 只占一个指针，判断起来也很方便。
派生类（子类）可以定义一个和基类（父类）成员同名的成员，这叫「覆盖」。在派生类（子类）中访问这类成员时，默认的情况是访问派生类中定义的成员。要在派生类中访问由基类定义的同名成员时，要使用作用域符号::。
下面看具体的例子：
// 基类
class father
{
public:
int money;
void func();
};
// 派生类
class son : public father // 继承
{
public:
int money; // 与基类同名成员变量
void func(); // 与基类同名成员函数
void myfunc();
};
void son::myfunc()
{
money = 100; // 引用的是派生类的money
father::money = 100; // 引用的是基类的money
func(); // 引用的是派生类的
father::func(); // 引用的是基类的
}
相当于 son 对象占用的存储空间：
我们都知道基类的 public 成员，都是可以被派生类成员访问的，那么基类的 protected、private 成员，分别可以被派生类成员访问吗？带着这个问题，我们可以先看下面的栗子：
class father
{
public:
int npublic; // 公有成员
protected:
int nprotected; // 保护成员
private:
int nprivate; // 私有成员
};
class son : public father
{
void func()
{
npublic = 1; // ok
nprotected = 1; // error
nprivate =1; // ok，访问从基类继承的protected成员
son a;
a.nprotected = 1; // error,a不是当前对象
}
};
int main()
{
father f;
son s;
f.npublic; // ok
s.npublic; // ok
f.nprotected; // error
s.nprotected; // error
f.nprivate; // error
s.nprivate; // error
}
基类的 protected、private 成员对于派生类成员的权限说明:
基类的 protected 成员 | 基类的 private 成员
---|---
派生类的成员函数可以访问当前对象的基类的保护成员| 不能被派生类成员访问
通常在初始化派生类构造函数时，派生类构造函数是要实现初始化基类构造函数的。那么如何在派生类构造函数里初始化基类构造函数呢？
class bug {
private :
int nlegs; int ncolor;
public:
int ntype;
bug (int legs, int color);
void printbug (){ };
};
class flybug : public bug // flybug 是bug 的派生类
{
int nwings;
public:
flybug( int legs,int color, int wings);
};
bug::bug( int legs, int color)
{
nlegs = legs;
ncolor = color;
}
// 错误的flybug 构造函数
flybug::flybug ( int legs,int color, int wings)
{
nlegs = legs; // 不能访问
ncolor = color; // 不能访问
ntype = 1; // ok
nwings = wings;
}
// 正确的flybug 构造函数：
flybug::flybug ( int legs, int color, int wings):bug( legs, color)
{
nwings = wings;
}
int main()
{
flybug fb ( 2,3,4);
fb.printbug();
fb.ntype = 1;
fb.nlegs = 2 ; // error. nlegs is private
return 0;
}
在上面代码例子中：
第24-30行的派生类构造函数初始化基类是错误的方式，因为基类的私有成员是无法被派生类访问的，也就无法初始化。
第33-36行代码是正确派生类构造函数初始化基类构造函数的方式，通过调用基类构造函数来初始化基类，在执行一个派生类的构造函数
之前，总是先执行基类的构造函数。
从上面的例子中我们也得知构造派生对象前，是先构造基类对象，那么在析构的时候依然依据“先构造，后初始化”的原则，所以派生类析构时，会先执行派生类析构函数，再执行基类析构函数。
如下栗子：
class base
{
public:
int n;
base(int i) : n(i)
{
cout << "base " << n << " constructed" << endl;
}
~base()
{
cout << "base " << n << " destructed" << endl;
}
};
class derived : public base
{
public:
derived(int i) : base(i)
{
cout << "derived constructed" << endl;
}
~derived()
{
cout << "derived destructed" << endl;
}
};
int main()
{
derived obj(3);
return 0;
}
输出结果：
base 3 constructed derived constructed derived destructed base 3 destructed
// 基类
class base {};
// 派生类
class derived : public base {};
base b; // 基类对象
derived d; // 派生类对象
b = d;
base & br = d;
base * pb = & d;
==注意：如果派生方式是 private 或 protected，则上述三条不可行==
// 基类
class base {};
// 派生类
class derived : protected base {};
base b; // 基类对象
derived d; // 派生类对象
所以派生方式是 private 或 protected，则是无法像 public 派生承方式一样把派生类对象赋值、引用、指针给基类对象。
public 派生方式的情况下，派生类对象的指针可以直接赋值给基类指针
base *ptrbase = & objderived;
通过强制指针类型转换，可以把 ptrbase 转换成 derived 类的指针
base * ptrbase = &objderived; derived *ptrderived = ( derived * ) ptrbase;
程序员要保证 ptrbase 指向的是一个 derived 类的对象，否则很容易会出错。
如对本文有疑问，请在下面进行留言讨论，广大热心网友会与你互动！！ 点击进行留言回复
如何在没有core文件的情况下用dmesg+addr2line定位段错误
用QT制作3D点云显示器——QtDataVisualization
网友评论