個人覺得這是一個典型的對象切片～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.
  回復  更多評論