酱坛子

个人觉得这是一个典型的对象切片～A AArray[10]中的10个A对象的实例是分配在栈上的静态对象，而不是分配在堆上的动态对象吧～这样的话其实就不存在多态了，因为多态是对指针对象而言的，于是当将子类对象赋给基类对象时，对象切片就发生了～  回复  更多评论
  

不是吧，栈内我还是可以调用函数的，再入栈一次就是了，我仍然可以使用指针方式进行参数传递。
确实，这个是一个切片现象。
呵呵
老兄 发觉这人好少啊 我想搬去csdn了 那人好多  回复  更多评论
  

Elvis說的沒錯
很典型的Object Slicing
請看Effective C++ 條款20  回复  更多评论
  

这根本不是多态的运用方式,C++下使用多态要用基类指针的方式,看来你还需要加强下基础  回复  更多评论
  

恩，我马上去瞧瞧Effective C++ 条款20，汗 我还没看到那

但是这个不是多态需要的基类指针的方式我就表示怀疑了，
只要virtual了base class的destructor 感觉后面的问题就可以解决了

多谢大家关心，不过还是希望大家能详细点告诉我错在哪里 嘿嘿 基础差偶欢迎大家批评 呵呵 最近恶补基础


  回复  更多评论
  

PS：你说的这个问题在C++ CODING STANDARDS的第100条有论述~  回复  更多评论
  

呵呵 是的 Elvis兄

Don't treat arrays polymorphically

Pointers serve two purposes at the same time: that of monikers (small identifiers of objects), and that of array iterators (they can walk through arrays of objects using pointer arithmetic). As monikers, it makes a lot of sense to treat a pointer to Derived as a pointer to Base. As soon as the array iteration part enters the stage, however, such substitutability breaks down because an array of Derived isn't the same as an array of Base. To illustrate: Mice and elephants are both mammals, but that doesn't mean a convoy of a thousand elephants would be as long as one of a thousand mice.

Size does matter. When substituting a pointer to Derived to a pointer to Base, the compiler knows exactly how to adjust the pointer (if necessary) because it has enough information about both classes. However, when doing pointer arithmetic on a pointer p to Base, the compiler computes p[n] as *(p + n * sizeof(Base)), thus assuming that the objects lying in memory are all Base objectsand not objects of some derived type that might have a different size. Imagine, now, just how easy it is to tromp all over of an array of Derived if you convert the pointer marking its start to Base* (with compiler's silent approval) and then perform pointer arithmetic on that pointer (while the compiler doesn't blink an eye either)!

Such accidents are an unfortunate interaction between substitutability, which dictates that pointers to derived classes should be usable as pointers to their bases, and C's legacy pointer arithmetic, which assumes pointers are monomorphic and uses solely static information to compute strides.

To store arrays of polymorphic objects, you need an array (or, better still, a real container; see Item 77) of pointers to the base class (e.g., plain pointers or, better still, shared_ptrs; see Item 79). Then each pointer in the array refers to a polymorphic object, likely an object allocated on the free store. Or, if you want to expose an interface to a container of polymorphic objects, you need to encapsulate the entire array and offer a polymorphic interface for iteration.

Incidentally, a good reason to prefer references to pointers in interfaces is to make it clear that you're talking about one object, as opposed to possibly an array of them.
  回复  更多评论