基类与继承类指针转换问题

win_hate

原帖由 gvim 于 2005-11-21 11:25 发表


Car* c 和 Vehicle* v , 都是声明成指针.
如果是指针和对象,大概是这样:
type b;
type *a = &b;
这样才是候sir的说明a 是指针 b是对象.

这个没有本质区别啊， &b 是个指针的值啊。

是不是我学 c 的脑袋转不过来了，晕ing ....

converse

原帖由 win_hate 于 2005-11-21 11:20 发表
type A  指针指向一个 type B 对象本质上就是两种指针的转换，是吗？

在C++中,这个说法不成立,比如:

1. 
   
2. #include <iostream>
   
3. 
   
4. using namespace std;
   
5. 
   
6. class a
   
7. {
   
8. public:
   
9.         /*virtual*/ void f()
   
10.         {
    
11.                 cout << "in an";
    
12.         }
    
13. };
    
14. 
    
15. class b : public a
    
16. {
    
17. public:
    
18.         /*virtual*/ void f()
    
19.         {
    
20.                 cout << "in bn";
    
21.         }
    
22. };
    
23. 
    
24. int main()
    
25. {
    
26.                 // 指针指向对象的情况
    
27.         a *p2;
    
28.         a a1;
    
29.         b b1;
    
30.         p2 = &a1;
    
31.         p2->f();
    
32.         p2 = &b1;
    
33.         p2->f();
    
34. 
    
35.         // 指针转换
    
36.         b *p3;
    
37.         p3 = &b1;
    
38.         p2 = p3;
    
39.         p2->f();
    
40. 
    
41.         return 0;
    
42. }
    
43. 
    

复制代码

没有把virtual关键字添加上的时候,输出的结果都是a,但是给f()添加了virtual关键字之后,输出变成了a,b,b因为指针和虚函数实现了动态的绑定,也就是所谓的多态....

gvim

我也好久没有用C__了,凭印象说的,可能不严谨,在这里道歉

win_hate

我再琢磨琢磨........

win_hate

1. 
   
2. int main()
   
3. {
   
4.         // 指针指向对象的情况
   
5.         p2 = &b1;
   
6.         p2->f();
   
7. 
   
8.         // 指针转换
   
9.         b *p3;
   
10.         p3 = &b1;
    
11.         p2 = p3;
    
12.         p2->f();
    
13.   
    
14. }
    

复制代码

还是没明白，只考虑后两个输出。

1. 
   
2.   p2 = &b1;
   
3.         p2->f();
   

复制代码

是直接把指针指向对象。

1. 
   
2.         b *p3;
   
3.         p3 = &b1;
   
4.         p2 = p3;
   
5.         p2->f();
   

复制代码

是通过指针进行转换。

但从输出的情况看，不加 virtual 是 a, a。 加了 virtual 是 b, b. 好象总是一样的?

renstone921

侯sir说得不太准确。

这取决于几个因素.

动态绑定---动态绑定是根据在执行时的实际对象调用相应的方法。

首先,类的方法只有是virtual的才有可能进行动态绑定；

其次，这还取决于编译器是否可以获得足够的类型信息,如果编译器获得的实际类型信息不
全面时，编译器只能对绑定进行延迟。否则，编译器尽可能早的决定调用的方法。

具体地说，
就是函数的参数以引用类型(引用或指针）的形式传递参数时，对于虚拟成元函数，编译器只能采用迟绑定的形式。
函数参数以值得形式传递时，无论是普通成元函数还是虚拟成元函数，编译器都采用早期绑定的形式。

1. 
   
2. class Vehicle
   
3. {
   
4. public:
   
5.     virual void Start();
   
6.     void Stop();
   
7. };
   
8. 
   
9. class Car : public Vehicle
   
10. {
    
11. pubic:
    
12.    virtual void Start();
    
13.    void Stop();
    
14. };
    
15. 
    
16. void Move(Vehicle vehicle)
    
17. {
    
18.      vehicle.Start(); //这里，由于函数的参数是值类型，所以编译器可以获得足够的类型信息，采用早绑定
    
19. }
    
20. 
    
21. void Move(Vehicle& vehicle)
    
22. {
    
23.     vehicle.Start(); //这里，由于传递的是引用类型，同时Start方法是virtual德，所以采用动态绑定，实际调用的方法，取决于调用这个函数时，传入的实际对象的类型。
    
24.     vehicle.Stop(); //这里，由于Stop方法是一个普通函数，无论如何也不会进行动态绑定。
    
25. }
    

复制代码

至于采用这种策略，是因为性能要求，静态绑定的性能始终要比动态绑定的性能要高，编译器获得足够的类型信息时，尽可能采用静态绑定。

[ 本帖最后由 renstone921 于 2005-11-21 12:11 编辑 ]

renstone921

在Addison Wesley 出版的C++ FAQS, 2nd Edition中的FAQ 17.06中说:

Q：Can a derived class pointer be converted into a pointer to its public base class?
A：Such conversions are possible and don't even require a pointer cast.

class Vehicle { };
class Car : public Vehicle { };

void f(Vehicle* v) throw();

void g(Car* c) throw()
{
  f(c);  //Perfectly safe; no cast needed
}

私有继承表示的是"has a"的关系，亦即有一个的关系。

公有继承public derived-表示父类和子类是"is a"的关系，所以公有继承得出的子类的实例，必然是其公有基类的一个实例。所以，把子类实例的指针赋给基类的指针，是类型安全的，注意 is a关系。

converse

我吃饭的时候想了想,win_hate说的没错,两者是一样的情况,我扯到了别的东西上面了~~汗

converse

原帖由 win_hate 于 2005-11-21 11:56 发表
[code]
int main()
{
        // 指针指向对象的情况
        p2 = &b1;
        p2->f();

        // 指针转换
        b *p3;
        p3 = &b1;
        p2 = p3;
        p2->f(); ...

我吃饭的时候想了想,win_hate说的没错,两者是一样的情况,我扯到了别的东西上面了~~汗

renstone921

1、如果你以一个"基类之指针"指向一个"派生类之对象"，那么经由该指针你只能调用该基类所定义的函数
2、如果你以一个“派生类之指针”指向一个“基类之对象”，你必须先做明显的转型操作(explicit cast)，这种作法很危险，不符合真实生活经验，在设计上也许会带给程序员困惑；
3、如果积累和派生类都定义了“相同名称之函数”，那么通过对象指针调用成员函数时，到底调用了那个函数，必须视该指针的原始类型而定，而不是视指针实际所指的对象的类型而定，这与第1点其实意义相通。

侯sir在这样讲时，是基于mfc讲的，mfc作为一个在win3.1时代出现的c++框架，由于当时操作系统和硬件的限制，考虑到空间和时间效率，在mfc中尽量避免使用虚拟成元函数，第1个阐述的就是当你的成员函数根本就不是虚拟成元函数时，无论如何，编译器都采用静态绑定的策略，所以的除了上述结论--这个结论是基于完全放弃了使用虚拟成元函数动态绑定得出的。

2.用c语言描述一下。有下面两个结构

1. 
   
2. struct Date
   
3. {
   
4.     int year;
   
5.     int month;
   
6.     int day;
   
7. };
   
8. 
   
9. struct DateTime
   
10. {
    
11.     int year;
    
12.     int month;
    
13.     int day;
    
14.     int hour;
    
15.     int minute;
    
16.     int second;
    
17. };
    
18. 
    
19. void test()
    
20. {
    
21.     struct DateTime* dateTime = NULL;
    
22.     struct Date* date = malloc(sizeof(struct Date));
    
23.     date->year = 2005;
    
24.     date->month = 21;
    
25.     date->day = 1;
    
26.    
    
27.     dateTime = (struct DateTime *)date;
    
28.     //现在dateTime获得了访问已&date的值开始，sizeof(struct DateTime)大小的存储空间并对齐进行
    
29.    //解释的权利。他把它所指向的第一个4字节解释为year...诸如此类。
    
30. 
    
31. }
    
32. 
    

复制代码

这也说明了这种向下转换不安全的原因。所以c++语言里面引入了dynamic_cast这个转换运算符，来保证进行安全的转换。

3.这还是基于不使用虚拟成元函数这一基本条件进行阐述的。这也是mfc为何如此丑陋的原因之一。