侯杰深入浅出MFC中CPP学习

@font-face{
font-family:"Times New Roman";
}
@font-face{
font-family:"宋体";
}
@font-face{
font-family:"Symbol";
}
@font-face{
font-family:"Arial";
}
@font-face{
font-family:"黑体";
}
@font-face{
font-family:"Courier New";
}
@font-face{
font-family:"Wingdings";
}
@font-face{
font-family:"新宋体";
}
p.0{
margin:0pt;
margin-bottom:0.0001pt;
layout-grid-mode:char; text-align:justify;
font-size:10.5000pt; font-family:'Times New Roman'; }
div.Section0{
margin-top:72.0000pt;
margin-bottom:72.0000pt;
margin-left:90.0000pt;
margin-right:90.0000pt;
size:612.0000pt 792.0000pt;
}

1.多态原理 候杰
为了达到动态系结（后期系结）的目的，C++ 编译器透过某个表格，在执行时期「间接」
呼叫实际上欲系结的函式（注意「间接」这个字眼）。这样的表格称为虚拟函式表（常
被称为vtable）。每一个「内含虚拟函式的类别」，编译器都会为它做出一个虚拟函式表，
表中的每一笔元素都指向一个虚拟函式的位址。此外，编译器当然也会为类别加上一项
成员变数，是一个指向该虚拟函式表的指标（常被称为 vptr）。
虚拟函式表的内容是依据类别中的虚
拟函式宣告次序，一一填入函式指标。衍生类别会继承基础类别的虚拟函式表（以及所
有其他可以继承的成员），当我们在衍生类别中改写虚拟函式时，虚拟函式表就受了影
响：表中元素所指的函式位址将不再是基础类别的函式位址，而是衍生类别的函式位址。
#include <iostream>
#include <cassert>
using namespace std;
class A
{
public:
virtual void print()
{cout << "A/n" ;}
};
class B: public A
{
public:
// void print()
//{cout << "B/n";}
};
class C: public B
{
public:
void print()
{cout << "C/n";}
};
void main()
{
A a ,* pa;
B b;
C c;
a.print();
b.print();
c.print();
pa = & c;
pa->print();
pa = & a;
pa->print();


}
////////////////////////////////////////////////
此例在候杰的 深入浅出MFC的例子上改得.
我的理解:根据指针找虚表,调用虚表中的函数,派生类会复制一份虚表,本身若有与父类同名的虚函数,则改之.强制指针类型转换,不会转换虚表.
#include <iostream>
using namespace std;
class CObject
{
public:
virtual void Serialize() { cout << "CObject::Serialize() /n/n"; }
};

class CDocument : public CObject
{
public:
int m_data1;
void print()
{ cout << "print document" << endl;}
void func() { cout << "CDocument::func()" << endl;
Serialize();}

virtual void Serialize() { cout << "CDocument::Serialize() /n/n"; }
};

class CMyDoc : public CDocument
{
public:
int m_data2;
virtual void Serialize() { cout << "CMyDoc::Serialize() /n/n"; }
virtual void onlyDoc()
{ cout << "onlyDoc" << endl;}
};
//---------------------------------------------------------------
class Test
{
public:
virtual void Serialize();
};
void main()
{
CMyDoc mydoc;
CMyDoc* pmydoc = new CMyDoc;

cout << "#1 testing" << endl;
mydoc.func();

cout << "#2 testing" << endl;
((CDocument*)(&mydoc))->func();
// error ((CDocument*)(&mydoc))->onlyDoc();
cout << "#3 testing" << endl;
pmydoc->func();

cout << "#4 testing" << endl;
((CDocument)mydoc).func(); // 所谓的"截断"
cout << "#5 testing" << endl;
((Test*)(&mydoc))->Serialize();
cout << "#6 testing" << endl;
CDocument mt= (CDocument)mydoc; // 所谓的"截断",返回一个新建对象
mt.func();
}
//////////////////////////////////////////
#1 testing //调用子类的中的虚函数
CDocument::func()
CMyDoc::Serialize()

#2 testing
CDocument::func()
CMyDoc::Serialize()

print document
#3 testing
CDocument::func()
CMyDoc::Serialize()

#4 testing
CDocument::func()
CDocument::Serialize()

#5 testing
CMyDoc::Serialize()

E:/test/vc05/learn/Debug>lea
#1 testing
CDocument::func()
CMyDoc::Serialize()

#2 testing
CDocument::func()
CMyDoc::Serialize()

#3 testing
CDocument::func()
CMyDoc::Serialize()

#4 testing
CDocument::func()
CDocument::Serialize()

#5 testing
CMyDoc::Serialize()

#6 testing
CDocument::func()
CDocument::Serialize()
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
四種不同的物件生存方式（in stack、in heap、global、local static）
#include <iostream>
#include <string>
using namespace std;

class CDemo
{
public:
CDemo(const char* str);
~CDemo();
private:
char name[20];
};

CDemo::CDemo(const char* str) // 建構式
{
strncpy(name, str, 20);
cout << "Constructor called for " << name << '/n';
}

CDemo::~CDemo() // 解構式
{
cout << "Destructor called for " << name << '/n';
}

void func()
{
CDemo LocalObjectInFunc("LocalObjectInFunc"); // in stack
static CDemo StaticObject("StaticObject"); // local static 无论func被调用多少次,静态对象只被初始化一次
CDemo* pHeapObjectInFunc = new CDemo("HeapObjectInFunc"); // in heap

cout << "Inside func" << endl;

}

CDemo GlobalObject("GlobalObject"); // global static

void main()
{
CDemo LocalObjectInMain("LocalObjectInMain"); // in stack
CDemo* pHeapObjectInMain = new CDemo("HeapObjectInMain"); // in heap

cout << "In main, before calling func/n";
func();
cout << "In main, after calling func/n";

}
////////////////////////////////////////////
Constructor called for GlobalObject
Constructor called for LocalObjectInMain
Constructor called for HeapObjectInMain
In main, before calling func
Constructor called for LocalObjectInFunc
Constructor called for StaticObject
Constructor called for HeapObjectInFunc
Inside func
Destructor called for LocalObjectInFunc
In main, after calling func
Destructor called for LocalObjectInMain
Destructor called for StaticObject
Destructor called for GlobalObject
////////////////////////////////////////////////////////////////////////////////////////////////////