- 浏览: 225702 次
- 性别:
- 来自: 淄博
文章分类
- 全部博客 (666)
- java (6)
- android (9)
- 架构 (0)
- android游戏 (13)
- android系统 (14)
- c++ (14)
- 数据库 (10)
- javascript (2)
- 版本控制 (1)
- webservice (1)
- linux (5)
- uml (1)
- android多媒体部分 (16)
- java中的JNI (6)
- HTML5 (5)
- CSS3 (1)
- swing (13)
- 线程并发 (9)
- 分布式 (5)
- 云计算 (1)
- 通信协议 (4)
- xml (4)
- c# (1)
- lucene (0)
- ibatis (0)
- hibernate (3)
- struts1 (3)
- struts2 (4)
- jsf (0)
- spring (5)
- spring for android (0)
- 感悟 (2)
- jpa (1)
- android gis (1)
- jbpm (0)
- java设计模式 (8)
- java web (4)
- EXT js (0)
- node JS (2)
- python (3)
- c (17)
- weblogic (0)
- opencv (1)
最新评论
c++学习笔记十四
继承
1 类和面向对象编程
2 类的继承
继承和聚合
从基类中派生新类 头文件 Box.h示例代码如下:
#ifndef BOX_H
#define BOX_H
class Box{
//构造器
public:
Box(double lv=1.0,double wv=1.0,double hv=1.0);
private:
double length;
double width;
double height;
};
#endif
实现文件Box.cpp如下:
#include "box.h"
Box::Box(double lv,double wv,double hv):length(lv),width(wv),height
(hv){}
定义一个carton是Box的派生类,Carton.h头文件的示例代码如下:
#ifndef CARTON_H
#define CARTON_H
#include "Box.h"
class Carton: public Box{ //public是基类访问指定符
public:
Carton(const char* pStr="Cardboard");//构造器
~Carton();//析构函数
//成员变量
private:
char * pMaterial;//合成材料
};
#endif
实现文件Carton.cpp,示例代码如下:
#include "Carton.h"
#include <cstring>
//构造函数
Carton::Carton(const char* pStr){
pMaterial=new char[strlen(pStr)+1]; //分配空间
std::strcpy(pMaterial,pStr); //复制内容
}
//析构函数
Carton::~Carton(){
delete[] pMaterial;
}
使用派生类
#include <iostream>
#include "Box.h"
#include "Carton.h"
using std::cout;
using std::endl;
int main(){
Box myBox(40.0,30.0,20.0);
Carton myCarton;
Carton candyCarton("Thin cardboard");
cout<<endl
<<"myBox occupies"<<sizeof myBox<<"bytes"<<endl;
cout<<"myCarton occupies"<<sizeof myCarton<<"bytes"<<endl;
cout<<"candyCarton occupies"<<sizeof candyCarton<<"bytes"<<endl;
//以下两句在编译时会发生错误,因为length是Box的私有成员
// myBox.length=10.0;
//candyCarton.length=10.0;
return 0;
}
注: 其中每个数据成员占8个字节
3 继承下的访问控制
Carton.h头文件的示例代码如下 :
#ifndef CARTON_H
#define CARTON_H
#include "Box.h"
class Carton: public Box{ //public是基类访问指定符
public:
Carton(const char* pStr="Cardboard");//构造器
~Carton();//析构函数
//成员方法
double volume() const;
//成员变量
private:
char * pMaterial;//合成材料
};
#endif
实现文件Carton.cpp,示例代码如下:
#include "Carton.h"
#include <cstring>
//构造函数
Carton::Carton(const char* pStr){
pMaterial=new char[strlen(pStr)+1]; //分配空间
std::strcpy(pMaterial,pStr); //复制内容
}
//析构函数
Carton::~Carton(){
delete[] pMaterial;
}
//成员方法
double Carton::volume() const{
return length*width*height;
}
基类成员函数
基类头文件 Box.h
class Box{
public:
Box(double lv=1.0,double wv=1.0,double hv=1.0);
double volume() const;
private:
double length;
double width;
double height;
};
实现文件Box.cpp
#include "Box.h"
//构造函数
Box::Box(double lv,double wv,double hv):length(lv),width
(wv),height(hv){}
double Box::volume() const{
return length*width*height;
}
在派生类中使用基类函数
#include <iostream>
#include "Box.h"
#include "Carton.h"
using std::cout;
using std::endl;
int main(){
//实例化对象
Box myBox(40.0,30.0,20.0);
Carton myCarton;
Carton candyCarton("Thin cardboard");
cout<<endl
<<"myBox volume is"<<myBox.volume()<<endl;
cout<<"myCarton volume is"<<myCarton.volume<<endl;
cout<<"candyCarton volume
is"<<candyCarton.volume<<"bytes"<<endl;
}
4 把类的成员声明为protected
这样派生类可以访问其成员
5 派生成员的访问级别 public protected和private (默认) 共有9种不同的组
合
访问级别如下图所示
============ ===============
公共的基类 ------------------------> 派生类
============ ===============
公共成员 ------------------------> 公共
============ ===============
受保护的成员------------------------> 受保护的
============ ===============
私有成员 ------------------------> 继承但不能访问
============ ===============
============ ===============
受保护的基类 -----------------------> 派生类
============ ===============
公共成员 ------------------------> 受保护的
============ ===============
受保护的成员------------------------> 受保护的
============ ===============
私有成员 ------------------------> 继承但不能访问
============ ===============
============ ===============
私有的基类 ------------------------> 派生类
============ ===============
公共成员 ------------------------> 私有
============ ===============
受保护的成员------------------------> 私有
============ ===============
私有成员 ------------------------> 继承但不能访问
============ ===============
在类层次中使用访问指定符
改变继承成员的访问指定符 示例代码如下:
Box.h头文件
class Box{
public:
Box(double lv=1.0,double wv=1.0,double hv=1.0);
double volume() const;
private:
double length;
double width;
double height;
};
Box.cpp实现文件
#include "Box.h"
//构造函数
Box::Box(double lv,double wv,double hv):length(lv),width
(wv),height(hv){}
double Box::volume() const{
return length*width*height;
}
使用以下方法将派生类中的函数改为公共成员
class Package: private Box{
public:
using Box::volume;
};
6 派生类中的构造函数操作
调用基类的构造函数
class Carton:public Box{
//调用基类默认构造函数
Carton(const char * pStr ="Cardboard");
Carton(double lv,double wv,double hv,const char *
pStr="Cardboard");
//析构函数
~Carton();
//成员方法
double volume() const;
protected:
char * pMaterial;
}
实现文件Carton.cpp
#include "Carton.h"
#include <cstring>
#include <iostream>
using std::cout;
using std::endl;
//构造器
Carton::Carton(const char * pStr){
pMaterial=new char[strlen(pStr)+1];//分配空间
std::strcpy(pmaterial,pStr);
cout<<"Carton constructor 1"<<endl;
}
Carton::Carton(double lv,double wv,double hv,const char *
pStr):Box(lv,wv,hv){
pMaterial=new char[strlen(pStr)+1];
std::strcpy(pMaterlal,pStr);
cout<<"Carton constructor 2"<<endl;
}
Carton::~Carton(){
delete[] pMaterial;
}
double Carton::volume() const{
return length*width*height;
}
在程序实例化的时候,编译器会首先调用Box的构造器
派生类中的副本构造函数
Box myBox(2.0,3.0,4.0);
Box copyBox(myBox);
需要在基类中添加一个副本构造函数(副本构造参数指定为引用) Box.h
中添加如下代码
Box::Box(const Box & aBox):length(aBox.length),width
(aBox.width),height(aBox.height){
cout<<""<<endl;
}
在Carton.h中添加
Carton(const Carton & aCarton);//副本构造函数
派生类中也要添加自已的构造函数,在Carton.cpp中添加如下:
Carton::Carton(const Carton & aCarton):Box(aCarton){
pMaterial=new char[strlen(aCarton.pMaterisl)+1];//分配空间
strcpy(pMaterial,aCarton.pMaterial) ;
cout<<"Carton copy constructor"<<endl;
}
7 继承中的析构函数 (在派生类对象超出作用域,或位于自由存储区时,必
须要释放他) 先调用派生类中的析构函数,后调用基类中的析构函数
8 重复的成员名
示例代码如下:
class Base{
//构造函数
public:
Base(int number=10){value=number;}
//数据成员
protected:
int value;
}
派生类Derived
class Derived:public Base{
public:
Derived(int number=20){value=number;}
int total() const;
protected:
int value; //定义了重复成员名
}
使用时必需指定其作用域(使用基类名和作用域解析运算符) 示例代码如下
:
int Derived::total() const{
return value+Base::value;
}
重复的函数成员名
第一种情况:函数名相同,但参数列表不同
class Base{
public:
void doThat(int arg);
...
};
class Derived::public Base{
public:
void doThat(double arg);
using Base::doThat();
...
};
第二种情况:所有方面都相同
Derived object;
object.Base::doThat(3);//调用基类的函数
9 多重继承
派生类可以有任意多个直接基类(这个跟java有点不同)
多个基类,示例代码如下:
class CerealPack:public Carton,public Contents{
...
}
继承成员的模糊性
头文件的定义如下========================================
#ifndef BOX_H
#define BOX_H
class Box{
public:
Box(double lv=1.0,double wv=1.0,double hv=1.0); //构
造器
Box(const Box & aBox);//副本构造器
//析构函数
~Box();
private:
double length;
double width;
double height;
};
#endif
==========================================================
实现文件
#include "Box.h"
#include <iostream>
using std::cout;
using std::endl;
//默认构造器
Box::Box(double lv,double wv,double hv):length(lv),width
(wv),height(hv){
cout<<"Box constructor"<<endl;
}
//副本构造成器
Box::Box(const Box & aBox):length(lv),width(wv),height(hv){
cout<<"Box copy constructor called"<<endl;
}
//析构函数
Box::~Box(){
cout<<"Box destructor"<<endl;
}
//成员方法
double Box::volume() const{
return length*width*height;
}
===========================================================
以下是派生类
头文件Carton.h
#ifndef CARTON_H
#define CARTON_H
#include "Box.h"
class Carton: public Box{
//构造器
pulbic :
Carton(double lv=1.0,double wv=1.0,double
hv=1.0,const char * pStr="Cardboard",double dense=0.125,double thick=0.2);
//析构函数
~Carton();
double getWeight() const;
//成员变量
char * pMaterial;
double thickness; //厚度
double density; //密度
};
#endif
==========================================================
实现文件Carton.cpp
#include "Carton.h"
#include <cstring>
#include <iostream>
using std::cout;
using std::endl;
//构造器
Carton:: Carton(double lv,double wv,double hv,const char *
pStr,double dense,double thick):Box(lv,wv,hv),density(dense),thisckness
(thick){
pMaterial =new char[strlen(pStr)+1];//分配空间
strcpy(pMaterial,pStr);
cout<<"Carton constructor"<<endl;
}
//析构函数
Carton::~Carton(){
cout<<"Carton destructor"<<endl;
delete[] pMaterial;
}
//取得重量
double Carton::getWeight() const{
return 2*(length*width+width*height+height*length)
*thickness*density;
}
============================================================
Contents.h头文件
#ifndef CONTNETS_H
#define CONTENTS_H
class Contents{
//构造器
public:
Contents(const char * pStr="cereal",double
weight=0.3,double vol=0);
//析构函数
~Contents();
double getWeight() const;//取得重量
//成员变量
char* pName;
double volume;
double unItweight;
};
#endif
==============================================================
Contents.cpp实现文件
#include "Contents.h"
#inlcude <cstring>
#include <iostream>
using std::cout;
using std::endl;
//构造器
Contents::Contents(const char* pStr,double weight,double
vol):unitweight(weight),volume(vol){
pName=new char[strlen(pStr)+1];
std:strcpy(pName,pStr);
cout<<"Contents constructor"<<endl;
}
//析构函数
Contents::~Contents(){
delete[] pName;
cout<<"Contents destructor"<<endl;
}
//取得重量
double Contents::getWeight() const{
return volume*unitweight;
}
============================================================
现在把Carton和Contents类作为公共基类
CerealPack.h 头文件
#ifndef CERALPACK_H
#define CERALPACK_H
#include "Carton.h"
#include "Contents.h"
//CerealPack是carton和contents 的派生类
class CerealPack:public Carton,public Contents{
//构造器
public:
CerealPack(double length,double width,double
height,const char * cerealType);
//析构函数
~CerealPack();
};
#endif
==============================================================
CerealPack.cpp实现文件如下
#include <iostream>
#include "Carton.h"
#include "Contents.h"
#include "Cerealpack.h"
using std::cout;
using std::endl;
CerealPack::CerealPack(double length,double width,double
height,const char * cerealType):Carton
(length,width,height,"cadboard"),Contents(cerealType){
cout<<"CerealPack constructor"<<endl;
Contents::volume=0.9*Carton::volume();
}
=============================================================
使用多重继承 示例代码如下:
#include <iostream>
#include "CerealPack.h"
using std::endl;
using std::cout;
int main(){
CerealPack packofFlakes(8.0,3.0,10.0,"Cornflakes");
cout<<endl
<<"packofFlakes volume is"
<<packofFlakes.Carton::volume()
<<endl;
cout<<endl
<<"packofFlakes weight is"
<<packofFlakes.Crton::getWeight+packofFlakes.Contents::getWeight()
<<endl;
return 0;
}
重复的继承
虚基类 示例代码如下:(基类应只出现一次)
class Contents:public virtual Comon{
...
};
class Box:public virtual Common{
...
};
==========================================================
class Freebie:public Common{
...
};
class cerealPack:pulbic Carton,public Contents,publicFreebie{
...
};
如果Common也声明为Freebie的虚基类,CerealPack类就只能继承
Common类型的一个子对象
10 在相关的类类型之间的转换
把派生类转换为基类类型,示例代码如下:
Carton aCarton(40,50,60,"fiberboard");
Box aBox;
aBox=aCarton;
1 类和面向对象编程
2 类的继承
继承和聚合
从基类中派生新类 头文件 Box.h示例代码如下:
#ifndef BOX_H
#define BOX_H
class Box{
//构造器
public:
Box(double lv=1.0,double wv=1.0,double hv=1.0);
private:
double length;
double width;
double height;
};
#endif
实现文件Box.cpp如下:
#include "box.h"
Box::Box(double lv,double wv,double hv):length(lv),width(wv),height
(hv){}
定义一个carton是Box的派生类,Carton.h头文件的示例代码如下:
#ifndef CARTON_H
#define CARTON_H
#include "Box.h"
class Carton: public Box{ //public是基类访问指定符
public:
Carton(const char* pStr="Cardboard");//构造器
~Carton();//析构函数
//成员变量
private:
char * pMaterial;//合成材料
};
#endif
实现文件Carton.cpp,示例代码如下:
#include "Carton.h"
#include <cstring>
//构造函数
Carton::Carton(const char* pStr){
pMaterial=new char[strlen(pStr)+1]; //分配空间
std::strcpy(pMaterial,pStr); //复制内容
}
//析构函数
Carton::~Carton(){
delete[] pMaterial;
}
使用派生类
#include <iostream>
#include "Box.h"
#include "Carton.h"
using std::cout;
using std::endl;
int main(){
Box myBox(40.0,30.0,20.0);
Carton myCarton;
Carton candyCarton("Thin cardboard");
cout<<endl
<<"myBox occupies"<<sizeof myBox<<"bytes"<<endl;
cout<<"myCarton occupies"<<sizeof myCarton<<"bytes"<<endl;
cout<<"candyCarton occupies"<<sizeof candyCarton<<"bytes"<<endl;
//以下两句在编译时会发生错误,因为length是Box的私有成员
// myBox.length=10.0;
//candyCarton.length=10.0;
return 0;
}
注: 其中每个数据成员占8个字节
3 继承下的访问控制
Carton.h头文件的示例代码如下 :
#ifndef CARTON_H
#define CARTON_H
#include "Box.h"
class Carton: public Box{ //public是基类访问指定符
public:
Carton(const char* pStr="Cardboard");//构造器
~Carton();//析构函数
//成员方法
double volume() const;
//成员变量
private:
char * pMaterial;//合成材料
};
#endif
实现文件Carton.cpp,示例代码如下:
#include "Carton.h"
#include <cstring>
//构造函数
Carton::Carton(const char* pStr){
pMaterial=new char[strlen(pStr)+1]; //分配空间
std::strcpy(pMaterial,pStr); //复制内容
}
//析构函数
Carton::~Carton(){
delete[] pMaterial;
}
//成员方法
double Carton::volume() const{
return length*width*height;
}
基类成员函数
基类头文件 Box.h
class Box{
public:
Box(double lv=1.0,double wv=1.0,double hv=1.0);
double volume() const;
private:
double length;
double width;
double height;
};
实现文件Box.cpp
#include "Box.h"
//构造函数
Box::Box(double lv,double wv,double hv):length(lv),width
(wv),height(hv){}
double Box::volume() const{
return length*width*height;
}
在派生类中使用基类函数
#include <iostream>
#include "Box.h"
#include "Carton.h"
using std::cout;
using std::endl;
int main(){
//实例化对象
Box myBox(40.0,30.0,20.0);
Carton myCarton;
Carton candyCarton("Thin cardboard");
cout<<endl
<<"myBox volume is"<<myBox.volume()<<endl;
cout<<"myCarton volume is"<<myCarton.volume<<endl;
cout<<"candyCarton volume
is"<<candyCarton.volume<<"bytes"<<endl;
}
4 把类的成员声明为protected
这样派生类可以访问其成员
5 派生成员的访问级别 public protected和private (默认) 共有9种不同的组
合
访问级别如下图所示
============ ===============
公共的基类 ------------------------> 派生类
============ ===============
公共成员 ------------------------> 公共
============ ===============
受保护的成员------------------------> 受保护的
============ ===============
私有成员 ------------------------> 继承但不能访问
============ ===============
============ ===============
受保护的基类 -----------------------> 派生类
============ ===============
公共成员 ------------------------> 受保护的
============ ===============
受保护的成员------------------------> 受保护的
============ ===============
私有成员 ------------------------> 继承但不能访问
============ ===============
============ ===============
私有的基类 ------------------------> 派生类
============ ===============
公共成员 ------------------------> 私有
============ ===============
受保护的成员------------------------> 私有
============ ===============
私有成员 ------------------------> 继承但不能访问
============ ===============
在类层次中使用访问指定符
改变继承成员的访问指定符 示例代码如下:
Box.h头文件
class Box{
public:
Box(double lv=1.0,double wv=1.0,double hv=1.0);
double volume() const;
private:
double length;
double width;
double height;
};
Box.cpp实现文件
#include "Box.h"
//构造函数
Box::Box(double lv,double wv,double hv):length(lv),width
(wv),height(hv){}
double Box::volume() const{
return length*width*height;
}
使用以下方法将派生类中的函数改为公共成员
class Package: private Box{
public:
using Box::volume;
};
6 派生类中的构造函数操作
调用基类的构造函数
class Carton:public Box{
//调用基类默认构造函数
Carton(const char * pStr ="Cardboard");
Carton(double lv,double wv,double hv,const char *
pStr="Cardboard");
//析构函数
~Carton();
//成员方法
double volume() const;
protected:
char * pMaterial;
}
实现文件Carton.cpp
#include "Carton.h"
#include <cstring>
#include <iostream>
using std::cout;
using std::endl;
//构造器
Carton::Carton(const char * pStr){
pMaterial=new char[strlen(pStr)+1];//分配空间
std::strcpy(pmaterial,pStr);
cout<<"Carton constructor 1"<<endl;
}
Carton::Carton(double lv,double wv,double hv,const char *
pStr):Box(lv,wv,hv){
pMaterial=new char[strlen(pStr)+1];
std::strcpy(pMaterlal,pStr);
cout<<"Carton constructor 2"<<endl;
}
Carton::~Carton(){
delete[] pMaterial;
}
double Carton::volume() const{
return length*width*height;
}
在程序实例化的时候,编译器会首先调用Box的构造器
派生类中的副本构造函数
Box myBox(2.0,3.0,4.0);
Box copyBox(myBox);
需要在基类中添加一个副本构造函数(副本构造参数指定为引用) Box.h
中添加如下代码
Box::Box(const Box & aBox):length(aBox.length),width
(aBox.width),height(aBox.height){
cout<<""<<endl;
}
在Carton.h中添加
Carton(const Carton & aCarton);//副本构造函数
派生类中也要添加自已的构造函数,在Carton.cpp中添加如下:
Carton::Carton(const Carton & aCarton):Box(aCarton){
pMaterial=new char[strlen(aCarton.pMaterisl)+1];//分配空间
strcpy(pMaterial,aCarton.pMaterial) ;
cout<<"Carton copy constructor"<<endl;
}
7 继承中的析构函数 (在派生类对象超出作用域,或位于自由存储区时,必
须要释放他) 先调用派生类中的析构函数,后调用基类中的析构函数
8 重复的成员名
示例代码如下:
class Base{
//构造函数
public:
Base(int number=10){value=number;}
//数据成员
protected:
int value;
}
派生类Derived
class Derived:public Base{
public:
Derived(int number=20){value=number;}
int total() const;
protected:
int value; //定义了重复成员名
}
使用时必需指定其作用域(使用基类名和作用域解析运算符) 示例代码如下
:
int Derived::total() const{
return value+Base::value;
}
重复的函数成员名
第一种情况:函数名相同,但参数列表不同
class Base{
public:
void doThat(int arg);
...
};
class Derived::public Base{
public:
void doThat(double arg);
using Base::doThat();
...
};
第二种情况:所有方面都相同
Derived object;
object.Base::doThat(3);//调用基类的函数
9 多重继承
派生类可以有任意多个直接基类(这个跟java有点不同)
多个基类,示例代码如下:
class CerealPack:public Carton,public Contents{
...
}
继承成员的模糊性
头文件的定义如下========================================
#ifndef BOX_H
#define BOX_H
class Box{
public:
Box(double lv=1.0,double wv=1.0,double hv=1.0); //构
造器
Box(const Box & aBox);//副本构造器
//析构函数
~Box();
private:
double length;
double width;
double height;
};
#endif
==========================================================
实现文件
#include "Box.h"
#include <iostream>
using std::cout;
using std::endl;
//默认构造器
Box::Box(double lv,double wv,double hv):length(lv),width
(wv),height(hv){
cout<<"Box constructor"<<endl;
}
//副本构造成器
Box::Box(const Box & aBox):length(lv),width(wv),height(hv){
cout<<"Box copy constructor called"<<endl;
}
//析构函数
Box::~Box(){
cout<<"Box destructor"<<endl;
}
//成员方法
double Box::volume() const{
return length*width*height;
}
===========================================================
以下是派生类
头文件Carton.h
#ifndef CARTON_H
#define CARTON_H
#include "Box.h"
class Carton: public Box{
//构造器
pulbic :
Carton(double lv=1.0,double wv=1.0,double
hv=1.0,const char * pStr="Cardboard",double dense=0.125,double thick=0.2);
//析构函数
~Carton();
double getWeight() const;
//成员变量
char * pMaterial;
double thickness; //厚度
double density; //密度
};
#endif
==========================================================
实现文件Carton.cpp
#include "Carton.h"
#include <cstring>
#include <iostream>
using std::cout;
using std::endl;
//构造器
Carton:: Carton(double lv,double wv,double hv,const char *
pStr,double dense,double thick):Box(lv,wv,hv),density(dense),thisckness
(thick){
pMaterial =new char[strlen(pStr)+1];//分配空间
strcpy(pMaterial,pStr);
cout<<"Carton constructor"<<endl;
}
//析构函数
Carton::~Carton(){
cout<<"Carton destructor"<<endl;
delete[] pMaterial;
}
//取得重量
double Carton::getWeight() const{
return 2*(length*width+width*height+height*length)
*thickness*density;
}
============================================================
Contents.h头文件
#ifndef CONTNETS_H
#define CONTENTS_H
class Contents{
//构造器
public:
Contents(const char * pStr="cereal",double
weight=0.3,double vol=0);
//析构函数
~Contents();
double getWeight() const;//取得重量
//成员变量
char* pName;
double volume;
double unItweight;
};
#endif
==============================================================
Contents.cpp实现文件
#include "Contents.h"
#inlcude <cstring>
#include <iostream>
using std::cout;
using std::endl;
//构造器
Contents::Contents(const char* pStr,double weight,double
vol):unitweight(weight),volume(vol){
pName=new char[strlen(pStr)+1];
std:strcpy(pName,pStr);
cout<<"Contents constructor"<<endl;
}
//析构函数
Contents::~Contents(){
delete[] pName;
cout<<"Contents destructor"<<endl;
}
//取得重量
double Contents::getWeight() const{
return volume*unitweight;
}
============================================================
现在把Carton和Contents类作为公共基类
CerealPack.h 头文件
#ifndef CERALPACK_H
#define CERALPACK_H
#include "Carton.h"
#include "Contents.h"
//CerealPack是carton和contents 的派生类
class CerealPack:public Carton,public Contents{
//构造器
public:
CerealPack(double length,double width,double
height,const char * cerealType);
//析构函数
~CerealPack();
};
#endif
==============================================================
CerealPack.cpp实现文件如下
#include <iostream>
#include "Carton.h"
#include "Contents.h"
#include "Cerealpack.h"
using std::cout;
using std::endl;
CerealPack::CerealPack(double length,double width,double
height,const char * cerealType):Carton
(length,width,height,"cadboard"),Contents(cerealType){
cout<<"CerealPack constructor"<<endl;
Contents::volume=0.9*Carton::volume();
}
=============================================================
使用多重继承 示例代码如下:
#include <iostream>
#include "CerealPack.h"
using std::endl;
using std::cout;
int main(){
CerealPack packofFlakes(8.0,3.0,10.0,"Cornflakes");
cout<<endl
<<"packofFlakes volume is"
<<packofFlakes.Carton::volume()
<<endl;
cout<<endl
<<"packofFlakes weight is"
<<packofFlakes.Crton::getWeight+packofFlakes.Contents::getWeight()
<<endl;
return 0;
}
重复的继承
虚基类 示例代码如下:(基类应只出现一次)
class Contents:public virtual Comon{
...
};
class Box:public virtual Common{
...
};
==========================================================
class Freebie:public Common{
...
};
class cerealPack:pulbic Carton,public Contents,publicFreebie{
...
};
如果Common也声明为Freebie的虚基类,CerealPack类就只能继承
Common类型的一个子对象
10 在相关的类类型之间的转换
把派生类转换为基类类型,示例代码如下:
Carton aCarton(40,50,60,"fiberboard");
Box aBox;
aBox=aCarton;
相关推荐
c++学习笔记/知识要点精华版
C++ 学习笔记C++ 学习笔记C++ 学习笔记C++ 学习笔记
c++学习笔记.pdf
C++学习笔记C++学习笔记C++学习笔记C++学习笔记C++学习笔记
C++学习笔记
【C++学习笔记】一份详细的学习笔记,让你轻松掌握C++编程!
C++学习笔记.docx
C++学习笔记: 以学习、思考、记录、分享为乐。
c++完美学习笔记c++完美学习笔记c++完美学习笔记c++完美学习笔记
C++ 学习笔记C++ 学习笔记C++ 学习笔记C++ 学习笔记002
C++学习笔记
C++基础的学习笔记(其中的代码源件可私信留言) C++中的空头程序 使用C++书写hello world 学习变量 学习常量 标识符命名规则 数据类型 运算符 程序流程结构 数组 函数 指针 结构体
C++ 学习笔记C++ 学习笔记C++ 学习笔记C++ 学习笔记C++ 学习笔记003
C++ 学习笔记C++ 学习笔记C++ 学习笔记C++ 学习笔记C++ 学习笔记004
C++ 学习笔记C++ 学习笔记C++ 学习笔记C++ 学习笔记001
C++学习笔记经典(与C比较),是学习C++的好资料。
Visual C++学习笔记,切身学习体会和总结
适用人群:C++初学者及C++期末考试冲刺 此C++学习笔记是本人在学习中思考总结所得,能够很好地帮助你入门C++或冲刺期末考试,让你掌握C++基础。
该笔记是我在mooc上看C++程序设计时做的一些笔记,因为是突发学习C++,要什么就学习什么,现在已经学到“文件输入输出流”,因为现在的项目不需要用到模板的知识,所以暂时只学到这么多,之后肯定还得学的,这个老师...