- 浏览: 263273 次
- 性别:
- 来自: 济南
文章分类
- 全部博客 (303)
- c (31)
- c++ (16)
- java (18)
- c# (1)
- python (3)
- java web (6)
- oracle (7)
- sqlserver (2)
- mysql (2)
- android (24)
- android系统 (15)
- android多媒体部分 (15)
- android游戏 (12)
- linux (26)
- javaScript (1)
- ajax (1)
- node JS (2)
- html (5)
- apache (3)
- jboss (1)
- weblogic (0)
- 通信协议 (10)
- 云计算 (1)
- 分布式 (5)
- ejb (1)
- webservice (5)
- 设计模式 (16)
- JNI (6)
- swing (13)
- 版本控制 (1)
- UML (1)
- xml (4)
- spring (5)
- hibernate (5)
- struts1 (3)
- struts2 (4)
- ibatis (0)
- tomcat (2)
- 心得体会 (1)
- css (1)
- 嵌入式 (41)
- arm体系结构 (10)
继承
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++学习笔记十六
2013-05-14 21:50 826c with classes 尽量以const e ... -
c++学习笔记十七
2013-05-18 23:44 880构造、析构、赋值运算 c++会为一个空类声明一个copy构造函 ... -
c++学习笔记一
2012-09-03 15:25 609基本概念 第一个程序 h ... -
c++学习笔记二
2012-09-03 15:26 364处理基本数据类型 1 混合表达式 (向上转型) 2 赋 ... -
c++学习笔记三
2012-09-03 15:26 547选择和决策 比较数据值 1 关系运算符:< &g ... -
c++学习笔记五
2012-09-03 15:27 605while do-while for循环 循环和变 ... -
c++学习笔记六
2012-09-03 15:28 272指针 可以使用指针记 ... -
c++学习笔记七
2012-09-03 15:28 563使用函数编程 程序的分解 1 函数 定义函 ... -
c++学习笔记八
2012-09-03 15:29 601函数 1 函数的重载: 函数名相同,参数个数不同 ... -
c++学习笔记九
2012-09-20 23:14 703程序文件和预处理指令 1 程序文件 头文件:类型定 ... -
c++学习笔记十
2012-09-20 23:18 598创建自已的数据类型 1 对像的概念 2 c++中的结构 ... -
c++学习笔记十一
2012-09-20 23:20 247类 1 封装 继承 多 ... -
c++学习笔记十二
2012-09-20 23:20 694类的操作 1 类对象使用指针的三种情况: ... -
c++学习笔记十三
2012-09-20 23:31 674运算符重载 1 为自已的类实现运算符 运 ... -
c++学习笔记十五
2012-09-20 23:36 630虚函数和多态性 使用基类指针,示例代码如下(从Box派 ...
相关推荐
### C++ 学习笔记精华版 #### 一、C++ 语言概述 **1、历史背景** - **C++ 的江湖地位** - Java、C、C++、Python、C# 是当前主流的编程语言之一,而 C++ 在这些语言中以其高效性和灵活性著称。 - **C++ 之父 ...
C++学习笔记C++学习笔记C++学习笔记C++学习笔记C++学习笔记
C++学习笔记
这份"C++学习笔记"涵盖了C++的基础到高级概念,旨在帮助初学者和有一定经验的程序员深入理解并掌握C++。 在C++的学习过程中,以下几个关键知识点是不可或缺的: 1. **基础语法**:C++起源于C语言,因此它保留了...
C++是一种静态类型、编译式、通用的编程语言,它支持过程化编程、面向对象编程和泛型编程。C++广泛应用于软件开发领域,包括操作...以上内容覆盖了C++语言中一些基础知识点,对于学习和理解C++编程具有重要的指导意义。
【C++学习笔记】这份详尽的资源是为那些希望深入了解C++编程语言的人们精心准备的。C++是一种强大的、通用的编程语言,它的设计理念是面向对象,同时支持过程化编程,使得它在系统软件、应用软件、游戏开发、设备...
【C++ 学习笔记】深入理解编程与C++基础 C++是一种强大的、面向对象的编程语言,广泛应用于系统软件、游戏开发、嵌入式系统以及许多高性能应用。学习C++不仅仅是掌握语法,更重要的是理解编程的核心概念,以便更好...
C++核心学习笔记pdf
C++ 学习笔记C++ 学习笔记C++ 学习笔记C++ 学习笔记002
C++ 学习笔记C++ 学习笔记C++ 学习笔记C++ 学习笔记C++ 学习笔记003
C++ 学习笔记C++ 学习笔记C++ 学习笔记C++ 学习笔记C++ 学习笔记004
C++ 学习笔记C++ 学习笔记C++ 学习笔记C++ 学习笔记001
【C++学习笔记概述】 C++是一门强大的编程语言,其在C语言的基础上进行了扩展,引入了许多现代化的特性。这份笔记主要涵盖了C++的基础知识,包括C++11和C++17的新特性,旨在帮助初学者理解C++的核心概念。 ### C++...
C++学习笔记 本文档提供了C++语言的基础知识,包括输入输出、变量、数据类型、运算符、内存管理、指针、流程控制语句等。 输入输出 C++语言提供了多种输入输出方式,包括使用cin和cout对象。cin对象用于从标准...
《新手C++学习笔记》是一份专为编程初学者打造的资源,旨在帮助那些刚刚踏入C++编程领域的“菜鸟”快速成长。这份笔记包含了前辈们的实践经验总结,具有很高的学习价值。文档以.doc格式存储,方便读者使用常见的文字...
今天,让我们一起深入探究《黑马C++学习笔记》,这本涵盖了C++编程基础与核心概念的全面教材。 首先,C++的基础知识是每个学习者必须掌握的部分,这包括变量的声明与赋值、输出语句等基本操作。在C++中,变量的声明...
这份"C++学习笔记"涵盖了C++的基础概念、语法结构、面向对象编程以及可能的高级主题,旨在帮助初学者或者有经验的程序员巩固C++知识。 首先,C++是从C语言发展而来,它保留了C语言的效率,同时引入了类和对象的概念...
C++是一种强大的面向对象编程语言,它源自C语言并扩展了其...学习这些概念是成为C++程序员的第一步。在实际编程中,还需要理解类、对象、继承、多态等面向对象编程的概念,以及函数、模板、文件操作等更高级的主题。
《C++学习笔记经典(与C比较)》这份资料应该会详细讲解这些知识点,并通过实例来帮助读者深入理解C++与C的差异,以及如何在实际编程中应用C++的特性和功能。这份资料可能会涵盖基本语法、类和对象、模板、STL的使用...