使用VS2012建立MFC工程, 名为OOPMFC.
A.1 培训实习生
A.2 类与实例
对象是一个自包含的实体, 用一组可识别的特性和行为来标识.
首先, 实现一个”猫叫”功能:
void COOPMFCDlg::OnBnClickedButtonCat()
{
AfxMessageBox(_T("喵"),MB_ICONINFORMATION);
}
将猫叫内容做成一个函数, 放在OOPMFCDlg.cpp里:
LPCTSTR Shout()
{
return LPCTSTR(L"喵");
}
void COOPMFCDlg::OnBnClickedButtonCat()
{
AfxMessageBox(Shout(),MB_ICONINFORMATION);
}效果同上.
公用的函数应该放在公用的地方. 类就是具有相同的属性和功能的对象的抽象的集合.
为此, 建立一个Cat类, 放在Cat.h中.
class Cat
{
public:
LPCTSTR Shout()
{
return LPCTSTR(L"喵");
}
protected:
private:
};调用时, 改为:
#include "Cat.h"
...
void COOPMFCDlg::OnBnClickedButtonCat()
{
Cat cat;
AfxMessageBox(cat.Shout().c_str(),MB_ICONINFORMATION);
}A.3. 构造函数
给猫取一个名字, 需要设置Name变量, 所以需要自己定义构造函数.
#include <string>
class Cat
{
public:
Cat(){Name=L"无名";}
Cat(std::wstring name){Name=name;}
std::wstring Shout()
{
return std::wstring(L"我的名字叫")+Name+std::wstring(L" 喵~");
}
protected:
private:
std::wstring Name;
};A.4. 方法重载
方法重载可以在不改变原方法的基础上新增功能.
例如自己定义的无参数构造函数:
Cat(){Name=L"无名";}A.5. 属性和修饰符
属性是一个方法或一对方法, 但在调用他的代码看来,它只是一个字段,即属性适合于以字段的方式使用方法调用的场合.
字段是存储类要满足其设计所需要的数据,字段是与类相关的变量.
C#内容, C++没有发现这样的语法.
设置猫叫几声.
class Cat
{
public:
Cat(){Name=L"无名";shoutNum=3;}
Cat(std::wstring name){Name=name;}
std::wstring Shout()
{
std::wstring result;
for (int i=0;i<shoutNum;i++)
{
result+=L" 喵 ";
}
return std::wstring(L"我的名字叫")+Name+result;
}
int get()
{
return shoutNum;
}
void set(int value)
{
shoutNum=value;
}
protected:
private:
std::wstring Name;
int shoutNum;
};A.6. 封装
每个对象都包含它能进行操作所需要的所有信息, 这个特性称为封装. 封装的好处:
1. 减少耦合.
2. 类内部的实现可以自由地修改.
3. 类具有清晰的对外接口.
建立的Cat类, 就是封装.
但是共性的东西都在不同的类里面封装起来, 造成代码重复, 容易出错, 而且难以维护.
例如建立一个Dog类, 可以发现几乎所有代码都是一样的.
所以要使用”继承”来把共性的东西放到父类中, 由子类继承这些共性即可.
A.7. 继承
对象的继承是”is-a”的关系. 子类是父类的特殊化, 有父类的特征, 也有自己的特征.
继承的作用:
1. 子类有父类非private的属性和功能;
2. 子类可以扩展父类没有的属性和功能;
3. 子类可以重写父类已有的功能.
protected类成员对子类公开, 但是不对其他类公开.
继承的优点:
1. 公共的部分都放在了父类,使得代码得到了共享,避免了重复.
2. 继承使得修改或者扩展继承而来的实现都较为容易.
继承的缺点:
1. 父类变, 子类不得不变. 继承是类之间的一种强耦合关系
2. 继承会破坏包装, 使得父类实现细节暴露给子类.
新建一个父类Animal类:
#ifndef ANIMAL_H
#define ANIMAL_H
#include <string>
class Animal{
public:
Animal()
{
Name=L"无名";
}
Animal(std::wstring name)
{
Name=name;
}
int get()
{
return shoutNum;
}
void set(int value)
{
shoutNum=value;
}
protected:
std::wstring Name;
int shoutNum;
};
#endif重写Cat类:
#include <string>
#include "animal.h"
class Cat:public Animal
{
public:
Cat(std::wstring name=L"无名",int snum=3):
Animal(name)
{
shoutNum=snum;
}
std::wstring Shout()
{
std::wstring result;
for (int i=0;i<shoutNum;i++)
{
result+=L" 喵 ";
}
return std::wstring(L"我的名字叫")+Name+result;
}
int get()
{
return shoutNum;
}
void set(int value)
{
shoutNum=value;
}
//注意继承了shoutNum和Name, 不用再定义了.
};重写Dog类:
#include <string>
#include "animal.h"
class Dog:public Animal
{
public:
Dog(std::wstring name=L"无名",int snum=3):
Animal(name)
{
shoutNum=snum;
}
std::wstring Shout()
{
std::wstring result;
for (int i=0;i<shoutNum;i++)
{
result+=L" 汪 ";
}
return std::wstring(L"我的名字叫")+Name+result;
}
int get()
{
return shoutNum;
}
void set(int value)
{
shoutNum=value;
}
//注意继承了shoutNum和Name, 不用再定义了.
};客户端调用:
void COOPTestDlg::OnBnClickedButtonCat()
{
Cat cat(L"咪咪");
AfxMessageBox(cat.Shout().c_str(),MB_ICONINFORMATION);
}
void COOPTestDlg::OnBnClickedButtonDog()
{
Dog dog(L"旺财");
AfxMessageBox(dog.Shout().c_str(),MB_ICONINFORMATION);
}效果:
A.8. 多态
多态表示不同的对象可以执行相同的动作, 但是要通过它们自己的实现代码来执行.
多态特点有:
1. 子类以父类的身份出现;
2. 子类在工作时以自己的方式来实现;
3. 子类以父类的身份出现时, 子类特有的属性和方法不可以使用.
多态的实现:
1. 父类成员声明为virtual;
2. 子类重写父类的virtual成员.
3. 注意基类要定义虚析构函数. 否则子类的析构函数不会被调用.(参考: C++继承中的虚析构函数)
“动物叫声比赛”实现:
父类指针指向子类对象, 完成相同的动作Shout. 但是子类对象使用自己的Shout函数.
增加两个button和事件函数:
Animal** arrayAnimal=new Animal*[5];
void COOPTestDlg::OnBnClickedButtonSignin()
{
arrayAnimal[0]=new Cat(L"小花");
arrayAnimal[1]=new Dog(L"阿毛");
arrayAnimal[2]=new Dog(L"小黑");
arrayAnimal[3]=new Cat(L"娇娇");
arrayAnimal[4]=new Cat(L"咪咪");
GetDlgItem(IDC_BUTTON_Shout)->EnableWindow(TRUE);//使能"叫声比赛"按钮
}
void COOPTestDlg::OnBnClickedButtonShout()
{
for (int i=0;i<5;i++)
{
AfxMessageBox(arrayAnimal[i]->Shout().c_str(),MB_ICONINFORMATION);
}
}显示效果:
A.9 重构
父类又有新的子类添加进来, 有些类成员函数又需要重写, 造成了大量的代码重复. 把成员函数中的特异部分拿出来写成父类的虚函数, 通过多态方法实现子类需要的不同功能.
重写父类Shout方法, 并新增getShoutSound方法:
std::wstring Shout()
{
std::wstring result;
for (int i=0;i<shoutNum;i++)
{
result+=getShoutSound();
}
return std::wstring(L"我的名字叫")+Name+result;
}//protected方法
virtual std::wstring getShoutSound()
{
return L"";
}给Animal类加入Cattle类和Sheep类. 以Cattle类为例:
std::wstring getShoutSound()
{
return L"哞";
}效果:
A.10. 抽象类
把实例化没有任何意义的父类, 改成抽象类. 让抽象类拥有尽可能多的共同代码, 拥有尽可能少的数据. 实现上要注意:
1. 抽象类不能实例化. 所以抽象类是继承的起点. 被继承就是抽象类的唯一用途.
2. 抽象方法必须被子类重写;
3. 抽象类中只要有一个抽象方法, 就是抽象类, 即使还有其他方法存在.
C++抽象类定义: http://www.cnblogs.com/dongsheng/p/3343939.html
一、纯虚函数定义.
纯虚函数是在基类中声明的虚函数，它在基类中没有定义，但要求任何派生类都要定义自己的实现方法。在基类中实现纯虚函数的方法是在函数原型后加“=0”
二、引入原因：
1、为了方便使用多态特性，我们常常需要在基类中定义虚拟函数。
2、在很多情况下，基类本身生成对象是不合情理的。例如，动物作为一个基类可以派生出老虎、孔雀等子类，但动物本身生成对象明显不合常理。
为了解决上述问题，引入了纯虚函数的概念，将函数定义为纯虚函数:
virtual ReturnType Function()= 0;则编译器要求在派生类中必须予以重载以实现多态性。同时含有纯虚拟函数的类称为抽象类，它不能生成对象。这样就很好地解决了上述两个问题。
在示例程序中, 将基类的getShoutSound函数改为:
virtual std::wstring getShoutSound()=0;如果定义一个抽象基类的对象, 编译时会报错:
1>------ 已启动生成: 项目: OOPTest, 配置: Debug Win32 ------
1>正在编译...
1>OOPTestDlg.cpp
1>e:\cppprojects\ooptest\ooptest\ooptestdlg.cpp(113) : error C2259: “Animal”: 不能实例化抽象类
1> 由于下列成员:
1> “std::wstring Animal::getShoutSound(void)”: 是抽象的
1> e:\cppprojects\ooptest\ooptest\animal.h(33) : 参见“Animal::getShoutSound”的声明
1>生成日志保存在“file://e:\CppProjects\OOPTest\OOPTest\Debug\BuildLog.htm”
1>OOPTest - 1 个错误，0 个警告
========== 生成: 成功 0 个，失败 1 个，最新 0 个，跳过 0 个 ==========如果有子类没有重写抽象方法, 也会报错:
1>------ 已启动生成: 项目: OOPTest, 配置: Debug Win32 ------
1>正在编译...
1>OOPTestDlg.cpp
1>e:\cppprojects\ooptest\ooptest\ooptestdlg.cpp(115) : error C2259: “Cattle”: 不能实例化抽象类
1> 由于下列成员:
1> “std::wstring Animal::getShoutSound(void)”: 是抽象的
1> e:\cppprojects\ooptest\ooptest\animal.h(33) : 参见“Animal::getShoutSound”的声明
1>生成日志保存在“file://e:\CppProjects\OOPTest\OOPTest\Debug\BuildLog.htm”
1>OOPTest - 1 个错误，0 个警告
========== 生成: 成功 0 个，失败 1 个，最新 0 个，跳过 0 个 ==========程序效果图如A.9.
A.11. 接口
某些子类有特殊的成员函数完成特有的功能, 为了实现多态但又不能让父类拥有这种功能. 这时, 可以使用接口类定义一个抽象类, 将接口以纯虚函数的形式封装起来. 让有特殊需求的子类去继承并实现相应的功能.
在应用中, 以接口类的指针指向子类去调用接口类中的这些方法, 就可以实现多态了.
相当于子类同时继承了父类和接口类.
接口是把隐式公共方法和属性组合起来, 以封装特定功能的一个集合. 一旦类实现了接口, 类就可以支持接口所指定的所有属性和成员.声明接口在语法上与声明抽象类完全相同, 但不允许提供接口中任何成员的执行方式.
C#中由interface关键字, C++没有. 要实现相似的功能, 可以使用抽象类代替. 抽象类的所有成员函数都是纯虚函数.
(语法参考: http://blog.csdn.net/qq1987924/article/details/7776787)
示例程序中, 加入接口类IChange, 再加入Monkey类, 加入叮当猫MachineCat和孙悟空StongMonkey类:
#ifndef I_CHANGE_H
#define I_CHANGE_H
#include <string>
class IChange
{
public:
virtual std::wstring ChangeThings(std::wstring things)=0;
};
#endif#include <string>
#include "animal.h"
class Monkey:public Animal
{
public:
Monkey(std::wstring name=L"无名",int snum=3):
Animal(name)
{
shoutNum=snum;
}
std::wstring getShoutSound()
{
return L"吱";
}
int get()
{
return shoutNum;
}
void set(int value)
{
shoutNum=value;
}
//注意继承了shoutNum和Name, 不用再定义了.
};#ifndef STONE_MONKEY_H
#define STONE_MONKEY_H
#include "monkey.h"
#include "i_change.h"
class StoneMonkey: public Monkey,public IChange{
public:
StoneMonkey(std::wstring name=L"无名",int snum=3)
:Monkey(name,snum){}
std::wstring ChangeThings(std::wstring things)
{
return Monkey::Shout()+L"我会七十二变, 可以变出: "+things;
}
};
#endif#ifndef MACHINE_CAT_H
#define MACHINE_CAT_H
#include "cat.h"
#include "i_change.h"
class MachineCat: public Cat,public IChange
{
public:
MachineCat(std::wstring name=L"无名",int snum=3)
:Cat(name,snum){}
std::wstring ChangeThings(std::wstring things)
{
return Shout()+L"我有万能口袋, 我可以变出: "+things;
}
};
#endif为”变东西”按钮添加事件处理函数:
void COOPTestDlg::OnBnClickedButtonChangethings()
{
IChange** arrayIChange=new IChange*[2];
arrayIChange[0]=new MachineCat(L"叮当");
arrayIChange[1]=new StoneMonkey(L"孙悟空");
for (int i=0;i<2;i++)
{
AfxMessageBox(arrayIChange[i]->ChangeThings(L"各种各样的东西").c_str(),MB_ICONINFORMATION);
}
//IChange* pIChange= new MachineCat(L"叮当");
//AfxMessageBox(pIChange->ChangeThings(L"各种各样的东西").c_str(),MB_ICONINFORMATION);
}
总结一下:
类是对象的抽象; 抽象类是类的抽象; 接口是对行为的抽象.
如果行为跨越不同类的对象, 可以使用接口; 对于一些相似的类, 可以使用抽象类作为基类
从设计角度讲, 抽象类是从子类中发现了公共的东西, 泛化出父类, 然后让子类继承, 是从下向上,从小到大的设计; 接口是根本不知道子类的存在, 方法如何实现还不确认, 预先定义,是从上往下,从大到小的设计.
扫一扫
280
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
