虚承和虚基cȝ定义是非常的单的Q同时也是非常容易判断一个承是否是虚?br>的，虽然q两个概늚定义是非常的单明的Q但是在C++语言中虚l承作ؓ(f)一个比较生
?ni)但是又是l对必要的组成部份而存在着Qƈ且其行ؓ(f)和模型均表现出和一般的l承体系
之间的巨大的差异Q包括访问性能上的差异Q，现在我们来d的从语言、模型、性能?br>应用{多个方面对虚承和虚基c进行研I?br> 首先q是先给l承和虚基类的定义?br> 虚承：(x)在承定义中包含了virtual关键字的l承关系Q?br> 虚基c：(x)在虚l承体系中的通过virtuall承而来的基c，需要注意的是：(x)
struct CSubClass : public virtual CBase {}; 其中CBaseUC为CSubClass
的虚基类Q而不是说CBase是个虚基类Q因为CBaseq可以不不是虚承体p?br> 中的基类?br> 有了上面的定义后Q就可以开始虚l承和虚基类的本质研I了Q下面按照语法、语义?br>模型、性能和应用五个方面进行全面的描述?br>
1. 语法
语法有语a的本w的定义所军_QM上来说非常的单，如下Q?br> struct CSubClass : public virtual CBaseClass {};
其中可以采用public、protected、private三种不同的承关键字q行修饰Q只?br> 保包含virtual可以了Q这样一来就形成了虚l承体系Q同时CBaseClass成?br> 了CSubClass的虚基类了?br> 其实q没有那么的单，如果出现虚承体pȝq一步承会(x)出现什么样的状况呢Q?br> 如下所C：(x)
/*
* 带有数据成员的基c?br> */
struct CBaseClass1
{
CBaseClass1( size_t i ) : m_val( i ) {}
size_t m_val;
};
/*
* 虚拟l承体系
*/
struct CSubClassV1 : public virtual CBaseClass1
{
CSubClassV1( size_t i ) : CBaseClass1( i ) {}
};
struct CSubClassV2 : public virtual CBaseClass1
{
CSubClassV2( size_t i ) : CBaseClass1( i ) {}
};
struct CDiamondClass1 : public CSubClassV1, public CSubClassV2
{
CDiamondClass1( size_t i ) : CBaseClass1( i ), CSubClassV1( i ), CSubClassV2( i ) {}
};
struct CDiamondSubClass1 : public CDiamondClass1
{
CDiamondSubClass1( size_t i ) : CBaseClass1( i ), CDiamondClass1( i ) {}
};
注意上面代码中的CDiamondClass1和CDiamondSubClass1两个cȝ构造函数初始化?br> 表中的内宏V可以发现其中均包含了虚基类CBaseClass1的初始化工作Q如果没有这
个初始化语句׃(x)D~译旉误，Z么会(x)q样呢？一般情况下不是只要?br> CSubClassV1和CSubClassV2中包含初始化可以了么？要解释该问题必须要明白虚
l承的语义特征，所以参看下面语义部分的解释?br>
2. 语义
在C++中虚函数必须要通过一U间接的q行Ӟ而不是编译时Q机制才能够Ȁz（
调用Q的函数Q而虚l承也是必须在运行时才能够进行定位访问的一U体制。存在，
但间接。其中关键就在于存在、间接和׃nq三U特征?br> 对于虚函数而言Q这三个特征是很好理解的Q间接性表明了他必dq行时根据实?br> 的对象来完成函数dQ共享性表象在基类?x)共享被子类重蝲后的虚函敎ͼ其实指?br> 相同的函数入口?br> 对于虚承而言Q这三个特征如何理解呢？存在卌Cl承体系和虚基类实存在Q?br> 间接性表明了在访问虚基类的成员时同样也必通过某种间接机制来完成（下面模型
中会(x)讲到Q，׃n性表象在虚基cM(x)在虚l承体系中被׃nQ而不?x)出现多份拷贝?br> 那现在可以解释语法小节中留下来的那个问题了，“Z么一旦出C虚基c，必
d每一个承类中都必须包含虚基cȝ初始化语?#8221;。由上面的分析可以知道，
虚基cL被共享的Q也是在承体pM无论被承多次Q对象内存模型中均只?br> 出现一个虚基类的子对象Q这和多l承是完全不同的Q，q样一来既然是׃n的那?br> 每一个子c都不会(x)独占Q但是总还是必要有一个类来完成基cȝ初始化过E（因ؓ(f)
所有的对象都必被初始化，哪怕是默认的）(j)Q同时还不能够重复进行初始化Q那?br> 底谁应该负责完成初始化呢QC++标准中（也是很自然的Q选择在每一ơ承子cM
都必M写初始化语句Q因为每一ơ承子cd能都?x)用来定义对象?j)Q而在最下层
l承子类中实际执行初始化q程。所以上面在每一个承类中都要书写初始化语句Q?br> 但是在创建对象时Q而仅仅会(x)在创建对象用的类构造函C实际的执行初始化语句Q?br> 其他的初始化语句都会(x)被压制不调用?br>
3. 模型
Z实现上面所说的三种语义含义Q在考虑对象的实现模型（也就是内存模型）(j)时就
很自然了。在C++中对象实际上是一个连l的地址I间的语义代表，我们来分析虚
l承下的内存模型?br> 3.1. 存在
也就是说在对象内存中必须要包含虚基类的完整子对象Q以便能够完成通过地址
完成对象的标识。那么至于虚基类的子对象?x)存攑֜对象的那个位|（头、中间?br> NQ则由各个编译器选择Q没有差别。（在VC8中无基类被声明在什么位|，
虚基cȝ子对象都?x)被攄在对象内存的NQ?br> 3.2. 间接
间接性表明了在直接虚基承子类中一定包含了某种指针Q偏UL表格Q来完成?br> q子c访问虚基类子对象（或成员）(j)的间接手D（因ؓ(f)虚基cd对象是共享的Q?br> 没有定关系Q，至于采用何种手段q译器选择。（在VC8中在子类中放|了
一个虚基类指针vbcQ该指针指向虚函数表中的一个slotQ该slot中存攑ֈ虚基
cd对象的偏U量的负|实际上就是个以补码表C的intcd的|在计虚
基类子对象首地址Ӟ需要将该偏U量取绝对值相加，q个主要是ؓ(f)了和虚表
中只能存放虚函数地址q一要求相区别，因ؓ(f)地址是原码表C的无符号intcd
的|(j)
3.3. ׃n
׃n表明了在对象的内存空间中仅仅能够包含一份虚基类的子对象Qƈ且通过
某种间接的机制来完成׃n的引用关pR在介绍完整个内容后?x)附上测试代码?br> 体现q些内容?br> 4. 性能
׃有了间接性和׃n性两个特征，所以决定了虚承体pM的对象在讉K时必?br> ?x)在旉和空间上与一般情冉|较大不同?br> 4.1. 旉
在通过l承cd象访问虚基类对象中的成员Q包括数据成员和函数成员Q时Q都
必须通过某种间接引用来完成，q样?x)增加引用寻址旉Q就和虚函数一P(j)Q?br> 其实是调整this指针以指向虚基类对象Q只不过q个调整是运行时间接完成的?br> Q在VC8中通过打开汇编输出Q可以查?.cod文g中的内容Q在讉K虚基cd?br> 成员时会(x)形成三条mov间接d语句Q而在讉K一般承类对象时仅仅只有一条mov
帔R直接d语句Q?br> 4.2. I间
׃׃n所以不同在对象内存中保存多份虚基类子对象的拯Q这栯之多l承
节省I间?br> 5. 应用
谈了那么多语aҎ(gu)和内容Q那么在什么情况下需要用虚l承Q而一般应该如何
用呢Q?br> q个问题其实很难有答案，一般情况下如果你确性出现多l承没有必要Q必要׃n
基类子对象的时候可以考虑采用虚承关p（C++标准ios体系是q样的）(j)。由于每
一个承类都必d含初始化语句而又仅仅只在最底层子类中调用，q样可能׃(x)?br> 得某些上层子cd到的虚基cd对象的状态不是自己所期望的（因ؓ(f)自己的初始化?br> 句被压制了）(j)Q所?span style="COLOR: red">一般徏议不要在虚基cM包含M数据成员Q不要有状态）(j)Q只
可以作ؓ(f)接口cL提供?br> 假定通过多个z路径l承名ؓ(f)X的成员，有下面三U可能性：(x)
1Q如果在每个路径中X表示同一虚基cL员，则没有二义性，因ؓ(f)׃n该成员的单个实例Q?br> 2Q如果在某个路径中X是虚基类的成员，而在另一路径中X是后代派生类的成员，也没有二义性——特定派生类实例的优先高于׃n虚基cd例?nbsp;
3Q如果沿每个l承路径X表示后代zcȝ不同成员Q则该成员的直接讉K是二义性的?br>
附录Q测试代?br>#include <ctime>
#include <iostream>
/*
* 带有数据成员的基c?br> */
struct CBaseClass1
{
CBaseClass1( size_t i ) : m_val( i ) {}
size_t m_val;
};
/*
* 虚拟l承体系
*/
struct CSubClassV1 : public virtual CBaseClass1
{
CSubClassV1( size_t i ) : CBaseClass1( i ) {}
};
struct CSubClassV2 : public virtual CBaseClass1
{
CSubClassV2( size_t i ) : CBaseClass1( i ) {}
};
struct CDiamondClass1 : public CSubClassV1, public CSubClassV2
{
CDiamondClass1( size_t i ) : CBaseClass1( i ), CSubClassV1( i ), CSubClassV2( i ) {}
};
struct CDiamondSubClass1 : public CDiamondClass1
{
CDiamondSubClass1( size_t i ) : CBaseClass1( i ), CDiamondClass1( i ) {}
};
/*
* 正常l承体系
*/
struct CSubClassN1 : public CBaseClass1
{
CSubClassN1( size_t i ) : CBaseClass1( i ) {}
};
struct CSubClassN2 : public CBaseClass1
{
CSubClassN2( size_t i ) : CBaseClass1( i ) {}
};
struct CMultiClass1 : public CSubClassN1, public CSubClassN2
{
CMultiClass1( size_t i ) : CSubClassN1( i ), CSubClassN2( i ) {}
};
struct CMultiSubClass1 : public CMultiClass1
{
CMultiSubClass1( size_t i ) : CMultiClass1( i ) {}
};
/*
* 不带有数据成员的接口基类
*/
struct CBaseClass2
{
virtual void func() {};
virtual ~CBaseClass2() {}
};
/*
* 虚拟l承体系
*/
// struct CBaseClassX { CBaseClassX() {i1 = i2 = 0xFFFFFFFF;} size_t i1, i2;};
struct CSubClassV3 : public virtual CBaseClass2
{
};
struct CSubClassV4 : public virtual CBaseClass2
{
};
struct CDiamondClass2 : public CSubClassV3, public CSubClassV4
{
};
struct CDiamondSubClass2 : public CDiamondClass2
{
};
/*
* 正常l承体系
*/
struct CSubClassN3 : public CBaseClass2
{
};
struct CSubClassN4 : public CBaseClass2
{
};
struct CMultiClass2 : public CSubClassN3, public CSubClassN4
{
};
struct CMultiSubClass2 : public CMultiClass2
{
};
/*
* 内存布局用类声明.
*/
struct CLayoutBase1
{
CLayoutBase1() : m_val1( 0 ), m_val2( 1 ) {}
size_t m_val1, m_val2;
};
struct CLayoutBase2
{
CLayoutBase2() : m_val1( 3 ) {}
size_t m_val1;
};
struct CLayoutSubClass1 : public virtual CBaseClass1, public CLayoutBase1, public CLayoutBase2
{
CLayoutSubClass1() : CBaseClass1( 2 ) {}
};
#define MAX_TEST_COUNT 1000 * 1000 * 16
#define TIME_ELAPSE() ( std::clock() - start * 1.0 ) / CLOCKS_PER_SEC
int main( int argc, char *argv[] )
{
/*
* cMpM的尺?
*/
std::cout << "================================ sizeof ================================" << std::endl;
std::cout << " ----------------------------------------------------------------" << std::endl;
std::cout << "sizeof( CBaseClass1 ) = " << sizeof( CBaseClass1 ) << std::endl;
std::cout << std::endl;
std::cout << "sizeof( CSubClassV1 ) = " << sizeof( CSubClassV1 ) << std::endl;
std::cout << "sizeof( CSubClassV2 ) = " << sizeof( CSubClassV2 ) << std::endl;
std::cout << "sizeof( CDiamondClass1 ) = " << sizeof( CDiamondClass1 ) << std::endl;
std::cout << "sizeof( CDiamondSubClass1 ) = " << sizeof( CDiamondSubClass1 ) << std::endl;
std::cout << std::endl;
std::cout << "sizeof( CSubClassN1 ) = " << sizeof( CSubClassN1 ) << std::endl;
std::cout << "sizeof( CSubClassN2 ) = " << sizeof( CSubClassN2 ) << std::endl;
std::cout << "sizeof( CMultiClass1 ) = " << sizeof( CMultiClass1 ) << std::endl;
std::cout << "sizeof( CMultiSubClass1 ) = " << sizeof( CMultiSubClass1 ) << std::endl;
std::cout << " ----------------------------------------------------------------" << std::endl;
std::cout << "sizeof( CBaseClass2 ) = " << sizeof( CBaseClass2 ) << std::endl;
std::cout << std::endl;
std::cout << "sizeof( CSubClassV3 ) = " << sizeof( CSubClassV3 ) << std::endl;
std::cout << "sizeof( CSubClassV4 ) = " << sizeof( CSubClassV4 ) << std::endl;
std::cout << "sizeof( CDiamondClass2 ) = " << sizeof( CDiamondClass2 ) << std::endl;
std::cout << "sizeof( CDiamondSubClass2 ) = " << sizeof( CDiamondSubClass2 ) << std::endl;
std::cout << std::endl;
std::cout << "sizeof( CSubClassN3 ) = " << sizeof( CSubClassN3 ) << std::endl;
std::cout << "sizeof( CSubClassN4 ) = " << sizeof( CSubClassN4 ) << std::endl;
std::cout << "sizeof( CMultiClass2 ) = " << sizeof( CMultiClass2 ) << std::endl;
std::cout << "sizeof( CMultiSubClass2 ) = " << sizeof( CMultiSubClass2 ) << std::endl;
/*
* 对象内存布局
*/
std::cout << "================================ layout ================================" << std::endl;
std::cout << " --------------------------------MI------------------------------" << std::endl;
CLayoutSubClass1 *lsc = new CLayoutSubClass1;
std::cout << "sizeof( CLayoutSubClass1 ) = " << sizeof( CLayoutSubClass1 ) << std::endl;
std::cout << "CLayoutBase1 offset of CLayoutSubClass1 is " << (char*)(CLayoutBase1 *)lsc - (char*)lsc << std::endl;
std::cout << "CBaseClass1 offset of CLayoutSubClass1 is " << (char*)(CBaseClass1 *)lsc - (char*)lsc << std::endl;
std::cout << "CLayoutBase2 offset of CLayoutSubClass1 is " << (char*)(CLayoutBase2 *)lsc - (char*)lsc << std::endl;
int *ptr = (int*)lsc;
std::cout << "vbc in CLayoutSubClass1 is " << *(int*)ptr[3] << std::endl;
delete lsc;
std::cout << " --------------------------------SI------------------------------" << std::endl;
CSubClassV1 *scv1 = new CSubClassV1( 1 );
std::cout << "sizeof( CSubClassV1 ) = " << sizeof( CSubClassV1 ) << std::endl;
std::cout << "CBaseClass1 offset of CSubClassV1 is " << (char*)(CBaseClass1 *)scv1 - (char*)scv1 << std::endl;
ptr = (int*)scv1;
std::cout << "vbc in CSubClassV1 is " << *(int*)ptr[0] << std::endl;
delete scv1;
/*
* 性能试
*/
std::cout << "================================ Performance ================================" << std::endl;
double times[4];
size_t idx = 0;
CSubClassV1 *ptr1 = new CDiamondClass1( 1 );
std::clock_t start = std::clock();
{
for ( size_t i = 0; i < MAX_TEST_COUNT; ++i )
ptr1->m_val = i;
}
times[idx++] = TIME_ELAPSE();
delete static_cast<CDiamondClass1*>( ptr1 );
CSubClassN1 *ptr2 = new CMultiClass1( 0 );
start = std::clock();
{
for ( size_t i = 0; i < MAX_TEST_COUNT; ++i )
ptr2->m_val = i;
}
times[idx++] = TIME_ELAPSE();
delete static_cast<CMultiClass1*>( ptr2 );
std::cout << "CSubClassV1::ptr1->m_val " << times[0] << " s" << std::endl;
std::cout << "CSubClassN1::ptr2->m_val " << times[1] << " s" << std::endl;
return 0;
}
试环境Q?br> 软g环境QVisual Studio2005 Pro + SP1, boost1.34.0
g环境QPentiumD 3.0GHz, 4G RAM
试数据Q?br>================================ sizeof ================================
----------------------------------------------------------------
sizeof( CBaseClass1 ) = 4
sizeof( CSubClassV1 ) = 8
sizeof( CSubClassV2 ) = 8
sizeof( CDiamondClass1 ) = 12
sizeof( CDiamondSubClass1 ) = 12
sizeof( CSubClassN1 ) = 4
sizeof( CSubClassN2 ) = 4
sizeof( CMultiClass1 ) = 8
sizeof( CMultiSubClass1 ) = 8
----------------------------------------------------------------
sizeof( CBaseClass2 ) = 4
sizeof( CSubClassV3 ) = 8
sizeof( CSubClassV4 ) = 8
sizeof( CDiamondClass2 ) = 12
sizeof( CDiamondSubClass2 ) = 12
sizeof( CSubClassN3 ) = 4
sizeof( CSubClassN4 ) = 4
sizeof( CMultiClass2 ) = 8
sizeof( CMultiSubClass2 ) = 8
================================ layout ================================
--------------------------------MI------------------------------
sizeof( CLayoutSubClass1 ) = 20
CLayoutBase1 offset of CLayoutSubClass1 is 0
CBaseClass1 offset of CLayoutSubClass1 is 16
CLayoutBase2 offset of CLayoutSubClass1 is 8
vbc in CLayoutSubClass1 is -12
--------------------------------SI------------------------------
sizeof( CSubClassV1 ) = 8
CBaseClass1 offset of CSubClassV1 is 4
vbc in CSubClassV1 is 0
================================ Performance ================================
CSubClassV1::ptr1->m_val 0.062 s
CSubClassN1::ptr2->m_val 0.016 s
l果分析Q?br> 1. ׃虚承引入的间接性指针所以导致了虚承类的尺怼(x)增加4个字节；
2. 由Layout输出可以看出Q虚基类子对象被攑֜了对象的NQ偏UMؓ(f)16Q，q且vbc
指针必须紧紧的接在虚基类子对象的前面Q所以vbc指针所指向的内容ؓ(f)“偏移 - 4”Q?br> 3. ׃VC8偏UL在了虚函数表中，所以ؓ(f)了区分函数地址和偏U，所以偏UL用补
码int表示的负|
4. 间接性可以通过性能来看出，在虚l承体系同通过指针讉K成员时的旉一般是一?br> c访问情况下?倍左叻IW合汇编语言输出文g中的汇编语句的安排?br>
]]>
class A{
public A { std::cout<<A<<}
}
class B: public A{
... // print B
}
class C: public A, pulic B {
... // print C
}
int main(){
C obj;
}
输出: AABC。承关pL三角形：(x)A->B->C加A->C?br>
问题是：(x)q三条边如果考虑虚承，每条Ҏ(gu)两种可能Q共八种。那么其他七U组合的
输出是什么?
~译? VC6.0
#include "stdafx.h"
#include "iostream"
using namespace std;
class AA {
public:
AA(){ std::cout<<"AA"<<endl;}
};
class BB: public virtual AA
{
public:
BB(){ std::cout<<"BB"<<endl;}
};
class CC: public virtual AA, public (virtual) BB //括号的virtual可有可无
{
public:
CC(){ std::cout<<"CC"<<endl;}
};
int main(int argc, char* argv[])
{
CC obj;
return 0;
}
输出: AA
BB
CC
其它情况~译?x)出?br>主要考察多承的虚基cd内存中只有一份copy,如果不用虚承的话，Ҏ(gu)造成二义性，~译不过:)
]]>
char c[20];
scanf("%s",c);
输入:this is a c program!
它接收到this后遇到空|认ؓ(f)对应%s的数据项已结束，后面的（包含I格Q不能输入?
你想输入带空格的字符Ԍ只有使用gets(c);
但遗憄是用gets()函数一ơ只能输入一个字W串?br> 2 ȝ
%d,遇到数字,'+','-'以外的字W结?可蟩q空?
%f,,%lf:遇到数字, '.', 'e','+','-'之外的字W结?可蟩q空?br>
%s,从第一个非I格字符L(fng)C一个空格结?
%c,遇到字符p?不管是空D是回车之cȝ.
假如E序中出现这L(fng)代码,scanf("%d,%s,%c,%c").虽然E序是以 ', '作ؓ(f)分隔??s是不认这?', '?它只认空?所以会(x)出现变量不能正确赋值的情况,如果你将','L,但由?c却遇到空格又不会(x)跌,所以也不会(x)满需?通过上面的我们知?%c遇到I格是不?x)蟩q的,所以我采取下面q个方式来解??c的前面加一个空格来处理,q样可以解决上面的所有问题了,所以我们在使用%c?要在前面加上一个空?/span>,Lq种?fn)惯可以省去不少ȝ?ch),q且在?c之前最好还加上一?span style="COLOR: #ff0000">fflush(stdin);用来清除~存.
3 gets()
功能:从stdin中d字符Ԍ直至接受到换行符或EOF时停止，q将d的结果存攑֜str指针所指向的字W数l中。换行符不作取串的内容，d的换行符被{换ؓ(f)null|q由此来l束字符丌Ӏ?br> 注意:本函数可以无限读取，不会(x)判断上限Q所以程序员应该保str的空间够大Q以便在执行L作时不发生溢出?br> 实例Q?include"stdio.h"
void main()
{
char str[15];
gets(str);
printf("%s/n",str);
}
]]>
<本文中排序都是采用的从小到大排序>
一、对intcd数组排序
int num[100];
Sample:
int cmp ( const void *a , const void *b )
{
return *(int *)a - *(int *)b;
}
qsort(num,100,sizeof(num[0]),cmp);
二、对charcd数组排序Q同intcdQ?
char word[100];
Sample:
int cmp( const void *a , const void *b )
{
return *(char *)a - *(int *)b;
}
qsort(word,100,sizeof(word[0]),cmp);
三、对doublecd数组排序Q特别要注意Q?
double in[100];
int cmp( const void *a , const void *b )
{
return *(double *)a > *(double *)b ? 1 : -1;
}
qsort(in,100,sizeof(in[0]),cmp)Q?
四、对l构体一U排?
struct In
{
double data;
int other;
}s[100]
//按照data的g到大将l构体排?关于l构体内的排序关键数据data的类型可以很多种Q参考上面的例子?
int cmp( const void *a ,const void *b)
{
return (*(In *)a).data > (*(In *)b).data ? 1 : -1;
}
qsort(s,100,sizeof(s[0]),cmp);
五、对l构体二U排?
struct In
{
int x;
int y;
}s[100];
//按照x从小到大排序Q当x相等时按照y从大到小排序
int cmp( const void *a , const void *b )
{
struct In *c = (In *)a;
struct In *d = (In *)b;
if(c->x != d->x) return c->x - d->x;
else return d->y - c->y;
}
qsort(s,100,sizeof(s[0]),cmp);
六、对字符串进行排?
struct In
{
int data;
char str[100];
}s[100];
//按照l构体中字符串str的字兔R序排?
int cmp ( const void *a , const void *b )
{
return strcmp( (*(In *)a)->str , (*(In *)b)->str );
}
qsort(s,100,sizeof(s[0]),cmp);
七、计几何中求凸包的cmp
int cmp(const void *a,const void *b) //重点cmp函数Q把除了1点外的所有点Q旋转角度排?
{
struct point *c=(point *)a;
struct point *d=(point *)b;
if( calc(*c,*d,p[1]) < 0) return 1;
else if( !calc(*c,*d,p[1]) && dis(c->x,c->y,p[1].x,p[1].y) < dis(d->x,d->y,p[1].x,p[1].y)) //如果在一条直U上Q则把远的放在前?
return 1;
else return -1;
}
PS:
其中的qsort函数包含?lt;stdlib.h>的头文g里，strcmp包含?lt;string.h>的头文g?
]]>
| class Transaction { // base class for all public: // transactions Transaction(); virtual void logTransaction() const = 0; // make type-dependent // log entry ... }; Transaction::Transaction() // implementation of { // base class ctor ... logTransaction(); // as final action, log this } // transaction class BuyTransaction: public Transaction { // derived class public: virtual void logTransaction() const; // how to log trans- // actions of this type ... }; class SellTransaction: public Transaction { // derived class public: virtual void logTransaction() const; // how to log trans- // actions of this type ... }; |
考虑执行q行代码时会(x)发生什么：(x)
| BuyTransaction b; |
很明?BuyTransaction 的构造函C(x)被调用，但是首先QTransaction 的构造函数必d被调用，zcd象中的基c部分先于派生类部分被构造。Transaction 的构造函数的最后一行调用虚函数 logTransactionQ但是结果会(x)让你大吃一惊，被调用的 logTransaction 版本是在 Transaction 中的那个Q而不?BuyTransaction 中的——即使被创徏的对象类型是 BuyTransaction。基cL造期_(d)虚函C来不?x)向下匹配（go downQ到zcR取而代之的是，那个对象的行为就好像它的cd是基cR非正式地讲Q?span style="COLOR: #ff0000">基类构造期_(d)虚函数禁?/span>?q个表面上看h匪夷所思的行ؓ(f)存在一个很好的理由。因为基cȝ构造函数在zcL造函C前执行，当基cL造函数运行时Q派生类数据成员q没有被初始化。如果基cL造期间调用的虚函数向下匹配（go downQ到zc，zcȝ函数理所当然?x)涉及(qing)到本地数据成员Q但是那些数据成员还没有被初始化。这׃(x)为未定义行ؓ(f)和?zhn)之晚矣的调试噩梦开了一张通行?/span>。调用涉?qing)到一个对象还没有被初始化的部分自然是危险的，所?C++ 告诉你此路不通?br> 在实际上q有比这更多的更深层ơ的原理。在zcd象的基类构造期_(d)对象的类型是那个基类的?span style="COLOR: #ff0000">不仅虚函C(x)解析到基c，而且语言中用到运行时cd信息Qruntime type informationQ的配gQ例如，dynamic_cast?typeidQ，也会(x)对象视为基cȝ型?/span>在我们的例子中，?Transaction 构造函数运行初始化 BuyTransaction 对象的基c部分时Q对象的cd?Transaction。C++ 的每一个配件将以如下眼光来看待它，q对它生这L(fng)感觉Q对象的 BuyTransaction Ҏ(gu)的部分还没有被初始化Q所以安全的对待它们的方法就是视若无睏V在zcL造函数运行之前，一个对象不?x)成Z个派生类对象?br>
同样的原因也适用于析构过E。一旦派生类析构函数q行Q这个对象的zcL据成员就被视为未定义的|所?C++ 将它们视ؓ(f)不再存在。在q入基类析构函数Ӟ对象成Z个基cd象，C++ 的所有配件——虚函数Qdynamic_casts {——都如此看待它?
]]>
void func()
{
/* do something */
}
p = func;
p的赋值可以不同，但一定要是函数的地址Qƈ且v名和q回cd相同?br>
传递回调函数的地址l调用?br>
现在可以p传递给另一个函敎ͼ调用者）(j)- caller()Q它?yu)调用p指向的函敎ͼ而此函数名是未知的：(x)
void caller(void(*ptr)())
{
ptr(); /* 调用ptr指向的函?*/
}
void func();
int main()
{
p = func;
caller(p); /* 传递函数地址到调用?*/
}
如果赋了不同的值给pQ不同函数地址Q，那么调用者将调用不同地址的函数。赋值可以发生在q行Ӟq样使你能实现动态绑定?br>
调用规范
到目前ؓ(f)止，我们只讨Z函数指针?qing)回调而没有去注意ANSI C/C++的编译器规范。许多编译器有几U调用规范。如在Visual C++中，可以在函数类型前加_cdeclQ_stdcall或者_pascal来表C其调用规范Q默认ؓ(f)_cdeclQ。C++ Builder也支持_fastcall调用规范。调用规范媄(jing)响编译器产生的给定函数名Q参C递的序Q从叛_左或从左到右Q，堆栈清理责QQ调用者或者被调用者）(j)以及(qing)参数传递机Ӟ堆栈QCPU寄存器等Q?br>
调用规范看成是函数cd的一部分是很重要的；不能用不兼容的调用规范将地址赋值给函数指针。例如：(x)
// 被调用函数是以int为参敎ͼ以int回?br>__stdcall int callee(int);
// 调用函数以函数指针ؓ(f)参数
void caller( __cdecl int(*ptr)(int));
// 在p中企囑֭储被调用函数地址的非法操?br>__cdecl int(*p)(int) = callee; // 出错
指针p和callee()的类型不兼容Q因为它们有不同的调用规范。因此不能将被调用者的地址赋值给指针pQ尽两者有相同的返回值和参数列?
]]>