Verne in Blogger

概念:

程序中的动态链接过程

程序在使用dll的地方

需要指定使用哪个dll

然后通过索引找到dll

中代码的地址，

然后程序跳到dll代码中，

执行代码，

执行完后返回原代码

继续执行。

结构：DLL组成和文件结构

种类：VC开发DLL种类

空工程中，没有任何代码，我们新建一对代码文件，如W15_1_dll.cpp和W15_1_dll.h

在h文件中，写一句代码：

extern  “C”  int  _declspec(dllexport)  FactorialFunc(int a);

extern表明这是一个全局函数。所有导出函数都是全局的。

“C”指明导出一个C风格函数。不需要改

_declspec(dllexport) 是导出关键词，在函数声明时带有该关键词的函数，都会被导出

后面是函数名。

Win32 DLL(4)——导出函数

编写CPP代码:

#include "W15_1_DLL.h”
int FactorialFunc(int a)
{
 int fact = 1;
 int i;
 for (i=1;i<=a;i++){
  fact *= i;
 }
 return fact;
}

Win32 DLL(5)——使用DLL

DLL不能单独运行，必须通过其他程序“链接”使用。在程序中使用dll有两种方法：隐式链接、显式链接

隐式链接时，系统在启动程序的时候同时也启动dll，在代码中可以像使用一般函数一样，使用dll中的函数。——需要使用dll的*.h文件和*.lib文件

显式链接时，必须在代码中明确指出dll名称，并且使用指针调用dll中的导出函数，在使用完后，需要释放dll。——不需要使用lib文件，仅需要*.h文件

Win32 DLL(6)—配置dll调试环境

DLL无法单独运行，因此调试dll往往需要建立一个与之搭配的“dll测试工程”。——很重要
Step1：准备workspace。
建一个新的目录W15_1,将dll工程copy到这个目录里，将原来的W15_1_dll.dsw拿出来放在W15_1中。
双击之，这时由于找不到原有的dsp工程文件，会弹出对话框，提示选择工程源文件，这时，找到： W15_1_dll.dsp，确定。
在当前工作空间中建立一个console类型的工程，名为“W15_1_TEST”选择“添加到当前工作空间”。
以后，两个工程分别叫做“DLL工程” 和“TEST工程”。

Step2：配置工程属性——非常重要
菜单->工程->设置，选择TEST工程，选择“调试”页，修改其中两项：

菜单->工程->设置，选择TEST工程，选择“连接”页，修改输出文件名：

同样，修改DLL工程的以上三个属性：

可调式对话，选择test.exe

工作目录，选择“  ..\debug  ”

输出文件，选择 “..\Debug\W15_1_DLL.dll”

最后，修改工程依赖性：菜单->工程->从属性

令test工程依赖于dll工程

Win32 DLL(10)——隐式链接

Step1：在test工程的W15_1_TEST.cpp开头处添加对dll头文件的引用；
Step2：向程序中添加DLL库文件，如下：

#include "../W15_1_DLL/W15_1_DLL.h"
#pragma comment(lib,"../W15_1_DLL/debug/W15_1_DLL.lib")

这样，就可以在下面的程序中使用阶乘函数了。

while(true){
printf("输入一个数字:\n");
scanf("%d",&n);
rt=FactorialFunc(n);
printf("阶乘结果为:%d\n",rt);
}

Win32 DLL(11)——显式链接

隐式链接，程序在启动时就加载整个dll。在程序规模比较大，使用大量dll时，这样的方式效率很低。

显式链接不需要lib文件，其加载和卸载都需要用户通过代码完成。分别由API函数：LoadLibrary和FreeLibrary，控制加载dll和卸载dll。

显示链接在使用时非常灵活，甚至不需要dll头文件，但用户必须要知道dll中的导出函数的信息，并且告诉程序该信息。

Win32 DLL(12)——显式链接

把test工程中所有隐式导入dll代码和调用注释掉。

Step1：定义要使用的dll函数指针，使用typedef

typedef int (*W15_1_DLL_func1)(int);

int FactorialFunc(int a);

定义的dll函数指针类型，必须要与原dll函数具有相同的参数和返回值；
定义该类型后，即可用W15_1_DLL_func1来“当作”dll中的FactorialFunc使用。

Step2：装载dll

HINSTANCE hdll;
hdll = LoadLibrary("W15_1_DLL.dll");

HINSTANCE是Windows的“实例句柄”，如果成功打开dll，则hdll会赋值一个指针。反之hdll==NULL

Step3：使用、卸载dll函数

if(hdll!=NULL){
W15_1_DLL_func1 mydllfunc=(W15_1_DLL_func1)GetProcAddress(hdll,"FactorialFunc");
rt = mydllfunc(7);
printf("显示链接,运算结果为%d\n",rt);
FreeLibrary(hdll);
}

GetProcAddress函数中，指明了要调用的dll函数名，该函数的参数和返回值则由先前定义的函数指针来确定。

Win32 DLL(15)——dll的调试

如果需要调试dll的代码，必须满足如下条件：

Dll工程是目前的活动工程

Dll工程中的“可执行调式对话”，必须正确设置并且可调试

Win32 DLL(16)——MFC框架

以上展示了一个最简单的Win32DLL的使用方法。大多数情况下，尤其是以后做算法的时候，写这样的dll应该就够用。

MFC提供了一套win32 dll模板，在新建dll时，如果选择“一个简单dll”，或者“能够导出某些符号的dll”，就会自动生成一个框架。我们以后者为例一起看一下。

Win32 DLL(17)——MFC框架

dll.h文件

dll.cpp文件

MFC DLL的创建和使用

MFC常规DLL(1)——特点、创建

特点：

可以在dll内部任意使用MFC类库编写程序。

生成的dll可以被所有支持dll技术的程序调用。

只能导出“非MFC风格”的函数，也无法导出MFC派生类

创建：新建，选择“MFC APPWizard [dll]”，选择：动态链接库使用共享MFC DLL

MFC常规DLL(2)——编程

建立工程后，在工程中添加一个对话框资源。添加几个控件，添加类、变量。

MFC常规DLL(3)——编程

在创建之后，工程并没有导出任何函数，需要自己编程实现。

向程序中添加cpp文件，命名为DlgExport.cpp，添加：

添加对应的h文件，声明dll导出函数

编译通过。

仿照上一个例子，建立dll的测试工程。

在test工程中，用隐式链接方式，调用dll。

#include "../W15_2_DLL/DlgExport.h"
#pragma comment(lib,"../W15_2_DLL_debug/W15_2_DLL.lib")

int main(int argc,char* argv[]){
int score1,score2;
printf("输入语文成绩:\n");
scanf("%d",&score1);
printf("输入数学成绩:\n");
scanf("%d",&score2);
return 0;
}

可以直接在控制台程序中直接调用MFC对话框

MFC扩展DLL(1)

可以使用dll来实现从MFC中派生一些可重用类

使用扩展DLL，可将MFC程序模块化，将若干个组建拼起来，作为一个整体使用。这样的方式，就好象我们用MFC现有的“零件”拼装成一个成型的“组建”，可以被其他程序方便的使用。

通过这样的方式，可以定制MFC，制作自己的控件、属性对话框等。

动态链接库小结

DLL是windows的核心技术之一。正是通过dll技术，Windows能将庞大的操作系统逐级分解，逐层设计，逐步完善，发展至今。

直到今天，微软仍在以dll为核心，开发windows。我们使用的补丁、编程使用的接口、各种软件对系统的调用，都是通过一个个dll导出函数来实现功能。

掌握dll的基本编写方法，也是我们保护自己工作成果的最简单的方式。

数据库开发技术简介

数据库开发实例

数据库开发技术简介——DAO

数据库开发技术简介——ODBC

数据库开发技术简介——OLE DB

数据库开发技术简介——ADO

实例说明和程序框架

(1) CDaoWorkspace类——DAO工作区类

(2) CDaoDatabase类——数据库对象

(3)CDaoRecordset类——数据记录集对象

DAO编程准备工作

AfxGetModuleState()->m_dwVersion = 0x0601;
// 更新mfc为6.01版本

 
//step4.1打开数据库，创建记录集合对象
 m_pDatabase = new CDaoDatabase;
 try{
  m_pDatabase->Open(m_DBFileName);
  m_pRecordset = new CDaoRecordset(m_pDatabase);
  m_List.EnableWindow(true);
 }
 catch (CDaoException* e){
  e->ReportError();
  delete m_pDatabase;
  m_pDatabase = NULL;
  e->Delete();
  return;
 }

 //step4.2 读取数据库中的“Student_Info”表的结构
    //写入FormView中的CListCtrl控件中。
 m_strTableName = _T("Student_Info"); // 设置当前操作的数据库表名称
 int nFields;
 CDaoFieldInfo fieldInfo;   // 取表的结构信息
 CDaoTableDef td(m_pDatabase);  // 表对象
 try{
  td.Open(m_strTableName);  //打开指定名称的表
  nFields = td.GetFieldCount(); //获取该表的栏数
  for (int j=0; j < nFields; j++){
   td.GetFieldInfo(j,fieldInfo); //获取每个栏的信息
   int nWidth = m_List.GetStringWidth(fieldInfo.m_strName) + 15;
   m_List.InsertColumn(j,fieldInfo.m_strName,LVCFMT_LEFT, nWidth);
  }
 }catch (CDaoException* e){
  e->ReportError(); 
  e->Delete();
  return false;
 }
 td.Close();

 //step 4.3 读取表的数据，写入FormView中的CListCtrl控件中。
 int nItem = 0;
 try{
  //拼一个SQL查询语句：select * from [Student_Info]
  CString strSelect(_T("Select * From ["));
  strSelect += m_strTableName;
  strSelect += _T("]");   
  //指定m_pRecordset类型为动态类型,同时查询
  m_pRecordset->Open(dbOpenDynaset,strSelect);
  
  while (!m_pRecordset->IsEOF()) {
   COleVariant var;
   var = m_pRecordset->GetFieldValue(0); //第0列
   m_List.InsertItem(nItem,strVARIANT(var));
   for (int i=0; i < nFields; i++){
    var = m_pRecordset->GetFieldValue(i);
    CString strItem = strVARIANT(var);
    int width1 = m_List.GetColumnWidth(i);
    int width2 = m_List.GetStringWidth(strItem)+15;
    if (width2 > width1){
     m_List.SetColumnWidth(i,width2);
    }
    m_List.SetItemText( nItem,i,strItem);
   }
   nItem++;
   m_pRecordset->MoveNext();
  }
 }
 catch (CDaoException* e)
 {
  e->ReportError(); 
  e->Delete();
  return false;
 }

DAO编程-----添加数据

void CW13_1View::OnAddButton() 
{
 //检查数据是否完整
 UpdateData(true);
 if (m_strName1.GetLength()<2 || m_strNum1.GetLength()<1)
 { MessageBox("必须填写姓名和学号");
  return;
 }
 CString strGender,strClass;
 m_Combo1.GetWindowText(strGender);
 m_Combo2.GetWindowText(strClass);
 //数据准备完毕，开始写入数据
 m_strTableName = "Sdudent_Info";
 if(!m_pDatabase->IsOpen()) return;          // 测试DAO数据库对象的有效性
 if(!m_pRecordset) return;
 if(m_pRecordset->IsOpen()) m_pRecordset->Close();
 // 拼一个SQL语句
 CString strSql;
 strSql.Format("insert into Student_Info(学号,姓名,性别,班级,EMail) \
      values('%s','%s','%s','%s','%s')",\
    m_strNum1,m_strName1,strGender,strClass,m_strEmail);  
 try{
  if(m_pDatabase->CanUpdate())
   m_pDatabase->Execute(strSql, dbDenyWrite|dbConsistent);
 }
 catch(CDaoException* e){
  e->ReportError();
  e->Delete();
  return;
 }

 //写入完成，更新view
 UpdateView();
}

DAO编程------编辑数据

BOOL CW13_1View::PreTranslateMessage(MSG* pMsg) 
{
 CWnd  *pwnd = GetDlgItem(IDC_LIST1); 
 if( pMsg->message == WM_KEYDOWN )  
    {   switch( pMsg->wParam ){  
  case VK_DELETE:
   if(GetFocus() == pwnd){ //判断焦点在不在IDC_LIST1上 
    DeleteItem();//将删除代码放在这里，做成一个函数
   }
   break;
  default:
   break;
  }
 }  
 return CFormView::PreTranslateMessage(pMsg);
}

bool CW13_1View::DeleteItem()
{ m_strTableName = "Student_Info";
 if(!m_pDatabase->IsOpen()) return false;
 if(!m_pRecordset) return false;
 if(m_pRecordset->IsOpen()) m_pRecordset->Close();
 //获取当前选择的项的索引
 int nSelect = m_List.GetSelectedCount(); 
 if (nSelect > 0) {
  CString strID; // 获取ID，根据ID拼删除SQL命令
  strID = m_List.GetItemText(nSelect, 0);
  CString strSQL;
  strSQL.Format("delete from %s where ID=%s",
   m_strTableName, strID);
  
  try{
   m_pDatabase->Execute(strSQL);
  }
  catch (CDaoException* e) {
   e->ReportError(); 
   e->Delete();
   return false;
  }
  m_List.DeleteItem(nSelect);
  UpdateData(false);
 }

 return true;
}

DAO编程----查找数据

void CW13_1View::OnFind1Button() 
{
 //精确查找代码
 if(!m_pDatabase->IsOpen()) return;
 if(!m_pRecordset)     return;
 if(m_pRecordset->IsOpen()) m_pRecordset->Close();

 UpdateData(true);
 CString strSelect;
 if (m_strName2.GetLength()==0 && m_strNum2.GetLength()==0)
 { MessageBox("请补充数据");
  return;
 }

 m_List.DeleteAllItems();

 if (m_strName2.GetLength()==0){ 
  strSelect.Format("SELECT * FROM Student_Info WHERE 学号 like '%s'", m_strNum2);
 }else if (m_strNum2.GetLength()==0){
  strSelect.Format("SELECT * FROM Student_Info WHERE 姓名 like '%s'", m_strName2);
 }else{
  strSelect.Format("SELECT * FROM Student_Info WHERE 姓名 like '%s' AND 学号 like '%s'",
   m_strName2,m_strNum2);
 }

 int nItem = 0;
 try{   // 取记录集的数据
  m_pRecordset->Open(dbOpenDynaset,strSelect);
 
  while (!m_pRecordset->IsEOF()) {
   COleVariant var;
   var = m_pRecordset->GetFieldValue(0);
   m_List.InsertItem(nItem,strVARIANT(var));
   for (int i=0; i < 5; i++){
    var = m_pRecordset->GetFieldValue(i);
    m_List.SetItemText( nItem,i,strVARIANT(var));
   }
   nItem++;
   m_pRecordset->MoveNext();
  }
 }
 catch (CDaoException* e){
  e->ReportError(); 
  e->Delete();
  return;
 }
}

小结

创建和使用对话框

CW6_1Dlg dlg;
m_pMainWnd = &dlg;
Int nResponse = dlg.DoModal();
If(nRespone == IDOK){
//TODO: Place code here to han

#include “stdafx.h”
#include “W6_1.h”
#include “W6_1Dlg.h”
#include “MyDlg1.h”

Void CW6_1Dlg::OnButton1(){
CMyDlg1 dlg;
If(dlg.DoModal()==IDOK){
MessageBox(“OK”):
}else{
MessageBox(“Cancel”);
}

对话框之间的数据传输

第一种模式：从主窗口中读取子窗口的数据

CMyDlg1 dlg1;
If(dlg1.DoModal()==IDOK){
Cstring dlgstring=dlg1.m_strEdit;
MessageBox(dlgstring);
}

class CMyDlg1 : public CDialog
{
// Construction
public:
 CMyDlg1(CWnd* pParent = NULL);   // standard constructor

CWnd*  m_pParent;

CMyDlg1::CMyDlg1(CWnd* pParent /*=NULL*/)
 : CDialog(CMyDlg1::IDD, pParent)
{
 //{{AFX_DATA_INIT(CMyDlg1)
 m_strMyEdit = _T("");
 m_nCurSliderPos = 0;
 m_pParent = pParent;
 //}}AFX_DATA_INIT
}

CMyDlg    dlg(this);

void CMyDlg1::OnButton1() 
{
 UpdateData(true);
 if (m_pParent != NULL)
  {
  CListBox *pListBox ;
  pListBox = (CListBox*)m_pParent->GetDlgItem(IDC_LIST1);
  pListBox->AddString(m_strMyEdit);
 }
 m_strMyEdit = "";
 UpdateData(false);
}

模式对话框和无模式对话框

void CW6_1Dlg::OnButton1(){
CMyDlg1* pMydlg = new CMyDlg1;//创建一个类对象
pMydlg->m_pParent = this;//指定其父指针
pMydlg->Create(IDD_MY_DIALOG1);//创建对话框
pMydlg->Showwindow(SW_NORMAL);//显示对话框

void CMyDlg1::OnOK() 
{
 DestroyWindow();
 delete this; 
 //CDialog::OnOK();
}
void CMyDlg1::OnCancel() 
{
 // TODO: Add extra cleanup here
 DestroyWindow();
 delete this;
 
 //CDialog::OnCancel();
}

MFC4.21类别组织框架图(Class Hierarchy)

对象类

再次强调MFC编程的核心思想:继承

常用MFC程序类型

MFC概述

演示：建立第一个MFC程序

利用AppWizard建立对话框程序

利用资源管理器添加按钮控件

利用ClassWizard为按钮控件添加消息响应函数

如下图执行建立MFC对话框程序的第一步

第二步:

在程序类型选择中，选择“基本对话框”

在此后均选择"下一步"

最后一步:

直至最后，选择完成。程序向导已经为我们生成了一个空的程序框架。

完成

编译后，该程序可以生成一个程序对话框风格的界面程序，点击确认或者取消，会关闭程序，不能做任何事情。

为程序添加一个按钮

打开资源编辑器，在右侧找到：控件工具箱

选择按钮控件，拖动到程序界面上

出现  Button1

右键属性：

可以修改按钮的资源I D

可以修改按钮标题

Ctrl+W 打开类向导

选择"Message Maps"(消息映射),确定Project,Class name是当前项目,当前编辑类名,再Object IDs中选中添加按钮的ID(IDC_BUTTON1),在Messages中选中"BN_CLICKED",再点击左侧"Add Function"按钮,将按钮的消息响应函数添加到"Member functions"中,点击"Edit Code"就能编辑该按钮的响应函数

MFC程序的文件组织

概念：Windows API 函数

实例：用Windows API编程

概念1:Windows基本数据类型

Windows基本数据类型表

程序中的对象对应一个唯一的句柄，
句柄存放在系统的句柄区域，
系统自动更改句柄指向的动态内存地址，
但对象的句柄总是不变的。

为了区分不同的对象类型，Windows定义了许多种不同的句柄，如常用的如下：

概念3：窗口类、WinMain

Windows为什么叫windows？
程序的主界面往往是一个包含各种功能的“窗口”
这种窗口，实际上是一个窗口类的对象。
窗口类：WNDCLASS
指定窗口的类型、属性、外形等特征
Windows程序有一个唯一的WinMain主函数。
WinMain函数中进行的操作：
定义窗口类对象
向系统注册窗口类对象
显示窗口

概念4：事件和消息----重要概念

“售货员”的工作：顾客不买东西时，售货员不产生任何动作。当顾客购物、询价时，售货员才回应。
Windows程序类似“售货员”
当程序启动、创建窗口后，程序进入“等待”状态，直到接受到某种“刺激”——如键盘点击、鼠标移动和点击、收到网络信息等——程序脱离等待状态，处理该“刺激”。

上述的种种“刺激”，称为“事件”
一个事件的要素：时间、地点、类型、内容。
为了描述事件要素，Windows定义了一个数据结构，称为“消息”（Message）。

Windows预先定义了大多数事件的消息，并为每种消息定义了消息标识码，如：

WM_LBUTTONDOWN      鼠标左键按下消息
WM_RBUTTONDBLCLK            鼠标右键双击消息

为了保证程序能始终等待响应用户的消息，程序会建立一个“死”循环，来不断等待处理消息。

死循环！怎么退出？
不要着急，“关闭程序”也是一个用户消息，当点击关闭时，会响应该消息，关闭程序。
程序不断检测是否有事件发生，如果有，则进入消息循环，分析这个事件的消息，并找到程序中对应的消息处理程序段， 执行处理程序，然后返回消息循环。

消息处理程序，专门用来响应各种消息。一般来说，用户需要自己编写消息处理函数代码，实现对消息的响应。

概念5：窗口过程函数

窗口函数是负责处理各种窗口消息的函数
完整的Windows程序，必须包含两个独立的函数：
WinMain 主函数 ：负责初始化主界面的各种元素、进行必要的设置、完成某些固定要做的功能，并启动消息循环，等待系统的消息响应。
WinProc 窗口函数 ：负责实现消息循环，在消息循环中实现各项程序功能。
关于窗口过程函数的具体执行过程，涉及到系统的回调函数、系统消息队列、系统消息解析、分发、响应等更深的内容。
我们在这里，不再做要求，仅需要大家知道Windows程序执行的基本原理。


Windows程序执行流程

再看Windows API编程

使用API的优点：直接操作系统，理论上讲，任何Windows程序，都可以用API组合实现。
缺点：非常繁琐，非常难懂，非常多（1000+）

码农前辈们的做法：对API进行再封装：
封装成类库，形成统一的框架：MFC
封装成各种语言开发包：VC、VB、Delphi、C++Builder

什么是MFC?
MFC = Microsoft  Foundation  Classes 微软基础类库

MFC是一个程序零件超市，其中已经定义好了所有零件的功能，和零件之间的关系；我们选择自己喜欢的零件，兜出一个新的应用程序。
——侯捷《深入浅出MFC》

MFC帮助我们把大量的API函数，利用面向对象原理，合理封装起来，具有清晰的逻辑性和层次性，大大降低程序开发难度。

MFC与Windows API的关系

MFC设计了许多许多类，每个类都可以看作是对某些Windows API的封装，通过引用MFC的类，可以方便的实现对Windows API的调用。

MFC编程的核心思想——继承

MFC提供了一组类库，但怎样才能使用这些类库灵活编程呢？——从MFC中继承，对派生类编程。

PPT

Windows编程原理部分结束！

从现在开始，我们开始挑战MFC！

#ifndef W1_EXAMPLE1_SHAPE_H
#define W1_EXAMPLE1_SHAPE_H
////////////////////
// 继承 和 多态  实例
////////////////////
//形状类
class CShape
{
public:
 CShape();
 ~CShape();
public:
 virtual float GetArea();   //基类中定义的虚函数
 void GetType();
 void GetCommon();      //公共的属性
};
//三角形
class CTriangle : public CShape    //继承
{
public:
 CTriangle(float h, float w);
 ~CTriangle();

public:

 float GetArea();    //重载基类的虚函数，实现多态   
 void  GetType();     

private:        //封装的信息隐藏
 float H,W;
};
//圆形
class CCircle: public CShape
{
public:
 CCircle(float r);
 ~CCircle();
 float GetArea();
 void  GetType();
private:
 float R;
};
#endif

#include "StdAfx.h"
#include "stdio.h"

#include "Shape.h"


///////////////////////////
//   CShape 
/////////////////////////

CShape::CShape()
{
}

CShape::~CShape()
{
}

float CShape::GetArea()
{
 printf("area=0.0\n");
 return 0.0;
}

void CShape::GetType()
{
 printf("This is a Shape\n");
}
void CShape::GetCommon()
{
 printf("This is a Common atribute\n");
}
////////////////////////////
// CTriangle
///////////////////////////
CTriangle::CTriangle(float h, float w)
{
 H = h;
 W = w;
}
CTriangle::~CTriangle()
{
}
 
float CTriangle::GetArea()
{
 printf("area=%f\n",H*W*0.5);
 return H*W*0.5;
} 
void CTriangle::GetType()
{
 printf("This is a Triangle\n");
}
///////////////////////////
//   圆形
///////////////////////
CCircle::CCircle(float r)
{
 R = r;
}
CCircle::~CCircle()
{ 
}
float CCircle::GetArea()
{
 printf("area=%f\n",3.14159*R*R);
 return 3.14159*R*R; 
}
void CCircle::GetType()
{
 printf("This is a Circle\n");
}

// W1_Example1.cpp : Defines the entry point for the console application.
//

#include "stdafx.h"
#include "stdlib.h"
#include "stdio.h"
#include "Shape.h"
int main(int argc, char* argv[])
{

 //继承性
 CShape  myShape;
 CTriangle myTriangle(1.5,1);
 CCircle  myCricle(1.5);

 printf("1111--------------\n");
 myShape.GetCommon();
 myTriangle.GetCommon();
 myCricle.GetCommon();

 //多态：
 //编译时多态  （针对非虚函数的重载） 
 //运行时多态 （针对虚函数的重载）
 CShape  *pShape;
 CTriangle *pTriangle;
 CCircle  *pCricle;

 printf("2222--------------\n");
 pShape = &myShape;
 pShape->GetType();     //基类 -> 基类 = 基类
 pShape->GetArea();

 pCricle = &myCricle;  
 pCricle->GetType();    //子类 -> 子类 = 子类
 pCricle->GetArea();
 
 printf("3333--------------\n");
 //运行时多态
 pShape = &myCricle;   //基类 -> 子类
 pShape->GetType();    //基类的GetType不是虚函数，仍调用基类方法，而非子类方法
 pShape->GetArea();    //基类的GetArea 是虚函数 ，运行时多态，调用子类方法 
 pShape = &myTriangle;  
 pShape->GetType();   
 pShape->GetArea();    //多态   
 
 printf("4444--------------\n");

 //编译时多态
 pCricle = (CCircle*)&myShape; //子类 ->  基类  
 pTriangle = (CTriangle*)&myShape;

 pCricle->GetType();    //子类重载了基类的GetType方法，
 pTriangle->GetType();  //因此将基类指针强制转换为子类指针后，将调用子类重载后的方法，为编译时多态

 pCricle->GetArea();   //这里需要注意 仍然是运行时的多态，调用的是基类的方法 
 pTriangle->GetArea();   //不常用，不需要记住


 printf("--------------\n"); 


 system("pause");
 return 0;
}