2008年5月2日星期五

C++继承,虚,转换规则探究

以下讨论的东西都是在VS2005下跑出来的,如果想知道别的编译器规则,请照跑一遍。以下是类定义,函数内容为打印出当前函数名称,所以就不再贴了。
class Base
{
public:
Base();
Base(const Base & o);
virtual ~Base();
virtual Base & operator = (const Base & o);

void function1();
virtual void function2();
void function3();
virtual void function4();
//virtual void function5();
virtual void function6();
};
class Derive : public Base
{
public:
Derive();
Derive(const Derive & o);
virtual ~Derive();
virtual Derive & operator = (const Derive & o);

void function1();
virtual void function2();
virtual void function3();
void function4();
//compiler error
//int function5();
protected:
virtual void function6();
public:
};
首先我们讨论继承下的构造/析构顺序。
pa = dynamic_cast(new Derive ());
delete pa;
Base::Base
Derive::Derive
Derive::~Derive
Base::~Base
关于这段代码多说两句,如果我们把class Derive : public Base中的public删除,就会出现C2243错误,看来默认是私有继承。
先是基类构造,然后是继承类构造。先是继承类析够,然后是基类析够。然后我们将virtual ~Base();的virtual删除,结果就变成了。
Base::Base
Derive::Derive
Base::~Base
注意继承类的析构没了。所以如果你打算让人继承你的类,记得将类的析构改成virtual,否则他怎么写析构都不会被调用的。
然后是虚函数继承。
pa->function1 ();
pa->function2 ();
pa->function3 ();
pa->function4 ();
结果是这样。
Base::function1
Derive::function2
Base::function3
Derive::function4
Derive::function6
看来,虚特性出来不出来完全看基类。注意到上面的function5么?假设你继承了一个类,打算写一个函数,和基类里面的某个虚函数具有一样的名称和参数,但是返回不一样。嘟嘟~~抱歉,编译器错误。而且注意function6,即使在继承类中声明说这是保护函数,也可以通过公开的基类函数的虚特性进行调用。
下面我们要说一下拷贝构造函数,这不可避免的要说到定义。
Derive::Derive(const Derive & o)
{
printf ("Derive::Derive copy constructer\n");
}
猜猜这个会出什么结果?
Base::Base
Derive::Derive copy constructer
要是经常看我blog的人就不会意外,继承类的拷贝构造函数调用的是基类的普通构造函数。如果你打算让基类也拷贝构造,那这么做。
Derive::Derive(const Derive & o):Base (o)
{
printf ("Derive::Derive copy constructer\n");
}
然后是拷贝构造函数的使用时机。运行代码如下,我们逐步分析。
Base ta = *pa;
Base::Base copy constructer
Base::~Base
当对象声明时,如果加一个=,则以=后的对象来构造当前对象,这是拷贝构造的第一个用法。
Derive tb = *static_cast(pa);
Base::Base copy constructer
Derive::Derive copy constructer
Derive::~Derive
Base::~Base
当然,如果我们声明继承类的时候,一样拷贝构造。
//compiler error
//Derive tc = ta;
当我们试图用基类构造继承类的时候,理所当然的,出错了。
void test1 (Base &)
{
printf ("test1\n");
}
test1(*pa);
输出:test1
如果我们以一个对象调用的时候,如果是引用,当然是不拷贝的。
void test2 (Base)
{
printf ("test2\n");
}
test2(*pa);
Base::Base copy constructer
test2
Base::~Base
如果是直接调用,首先是拷贝构造,然后调用,最后析构。
Base& test3 ()
{
printf ("test3\n");
return Base ();
}
pb = &test3();
test3
Base::Base
Base::~Base
当返回对象引用的时候,只有很正常的构造和析构。
Base test4 ()
{
printf ("test4\n");
return Base ();
}
pb = &test4();
test4
Base::Base
Base::~Base
返回对象本身的话,哎,怎么会这样?
熟悉语言的应该看出来了,return Base ();的时候,先跑了一次构造,建立在栈里面,返回的时候要copy到堆中。拷贝构造呢?
这就是传说中的返回构造优化拉,直接构造在堆上面,省掉一次copy,下面我们看看原始的状态。
Base& test5 ()
{
Base b;
printf ("test5\n");
return b;
}
pb = &test5();
Base test6 ()
{
Base b;
printf ("test6\n");
return b;
}
pb = &test6();
Base::Base
test5
Base::~Base
Base::Base
test6
Base::Base copy constructer
Base::~Base
Base::~Base
大家看到了?5的时候先构造,再传回,和返回对象引用的时候行为一致。6的时候可没有返回构造优化,于是先构造,然后拷贝。删除的时候先删除原始对象,再删除拷贝对象,大家可以自行证实这点。
我们再修改上面的调用为下面的。
Base td = test5();
Base::Base
test5
Base::~Base
Base::Base copy constructer
Base::~Base
首先是5的构造,析构,然后才是td的拷贝构造,析构。这个顺序,熟悉语言的人应该感觉到奇怪了吧。按照推论,应当是先拷贝再析构的。如果你这么觉得,还是先看完下面的东西吧。
Base te = test6();
Base::Base
test6
Base::Base copy constructer
Base::~Base
Base::~Base
这才是预计的顺序。注意,这里并没有调用两次拷贝构造。虽然贝壳并不了解机制,不过估计又是一种返回构造优化。
5中例子觉得迷惑的人,不妨在拷贝构造里面打个断点,看看你copy的对象是什么,无效对象!!!!
返回引用的情况下,一旦返回对象的生命周期结束了,返回的数据就无法保证有效。因此返回局部对象是非常危险的,唯一的里外就是3例子中在返回的时候构造一个新的对象而引发的返回构造优化。
下面是拷贝构造和operator =的区别和调用时间。
Base ya = *pa;
Base yb;
yb = *pa;
Base::Base copy constructer
Base::Base
Base::operator =
Base::~Base
Base::~Base
上面一个是拷贝构造,下面一个是普通构造加operator =。
最后是全部的定义和源码,类的定义参考最上面的。
void test1 (Base &)
{
printf ("test1\n");
}
void test2 (Base)
{
printf ("test2\n");
}
Base& test3 ()
{
printf ("test3\n");
return Base ();
}
Base test4 ()
{
printf ("test4\n");
return Base ();
}
Base& test5 ()
{
Base b;
printf ("test5\n");
return b;
}
Base test6 ()
{
Base b;
printf ("test6\n");
return b;
}
int _tmain(int argc, _TCHAR* argv[])
{
Base *pa, *pb;

pa = dynamic_cast(new Derive ());

// test inherit function rule
//pa->function1 ();
//pa->function2 ();
//pa->function3 ();
//pa->function4 ();
//pa->function6 ();

//test copy constructer
//pb = dynamic_cast(new Derive (*static_cast(pa)));
//delete pb;
//Base ta = *pa;
//Derive tb = *static_cast(pa);
//compiler error
//Derive tc = ta;
//test1(*pa);
//test2(*pa);
//pb = &test3();
//pb = &test4();
//pb = &test5();
//pb = &test6();
//Base td = test5();
//Base te = test6();

//diffrence between copy cotr and operator =
//Base ya = *pa;
//Base yb;
//yb = *pa;

delete pa;
return 0;
}

没有评论: