迭代遍歷內存中的公共基類的對象

Question

我想弄清楚如何遍歷一個容器（如std :: vector）的對象在內存中共享一個公共基類父類連續。

爲了演示這個問題，我們使用下面的例子。現在

class Base 
{ 
public: 
    Base(); 
    virtual void doStuff() = 0; 
}; 

class DerivedA : public Base 
{ 
private: 
    //specific A member variables 
public: 
    DerivedA(); 
    virtual void doStuff(); 
}; 

class DerivedB : public Base 
{ 
private: 
    //specific B member variables 
public: 
    DerivedB(); 
    virtual void doStuff(); 
}; 

，使用std :: vector的迭代會保持在連續內存中的對象，但我們會體驗到切片，因爲沒有空間的派生屬性。

因此，我們必須使用多態技術使用指針像這樣

int main() 
{ 
    std::vector<Base*> container; 
    container.push_back(new DerivedA()); 
    container.push_back(new DerivedB()); 

    for (std::vector<Base*>::iterator i = container.begin(); i!=container.end(); i++) 
    { 
     (*(*i)).doStuff(); 
    } 
} 

據我知道，應該工作正常鑑於類實現。

問題：現在 ，載體含有指針在連續內存中，但這並不意味着它們都指向地址。

因此，如果我希望能夠隨時刪除對象並將其插入到矢量中，那麼這些對象將遍佈整個內存中。

問： 好像每個人建議做它的std ::向量的方式，但爲什麼沒有考慮問題的是，它不是在內存中連續可迭代（假設我們實際使用的指針）？

我是否被迫做了複製麪食的方式？

int main() 
{ 

    std::vector<DerivedA> containerA; 
    DerivedA a; 
    containerA.push_back(a); 

    std::vector<DerivedB> containerB; 
    DerivedB b; 
    containerB.push_back(b); 

    for (std::vector<DerivedA>::iterator i = containerA.begin(); i!=container.end(); i++) 
    { 
     (*i).doStuff(); 
    } 
    for (std::vector<DerivedB>::iterator i = containerB.begin(); i!=container.end(); i++) 
    { 
     (*i).doStuff(); 
    } 
} 

我猜可能沒有真正解決這一點，因爲在內存中保存各種大小的物體線性並沒有真正意義，但如果任何人都可以給我一些意見，我將不勝感激。

Answer 1

std::vector<T>迭代假定在連續的存儲器中的對象是T類型，std::vector<T>::iterator::operator++認爲sizeof T是不變 - 即，它不參考特定實例爲大小的數據。

在本質上，你能想到的vector和vector::iterator爲薄的外觀在T* m_data指針，這樣iterator++真的只是一個基本的指針操作。

您可能需要使用自定義分配器和就地new準備資料，並伴有兩種索引，鏈接等或許認爲像http://www.boost.org/doc/libs/1_58_0/doc/html/intrusive/slist.html

參見boost::stable_vector

Answer 2

std::vector分配對象在連續的內存中，但你存儲在向量中的對象指針不是。這是你通過vector迭代的方式。以下代碼是用C++ 14編寫的。所描述的問題不能通過該解決方案解決，因爲對象指針被存儲在連續的存儲器中而不是實際的對象中。

#include <iostream> 
#include <memory> 
#include <vector> 
#include <algorithm> 
using namespace std; 

class Base 
{ 
public: 
    Base() {} 
    virtual void doStuff() = 0; 
}; 

class DerivedA : public Base 
{ 
private: 
    //specific A member variables 
public: 
    DerivedA() : Base() {} 
    virtual void doStuff() { 
     std::cout << "Derived Class A - Do Stuff" << std::endl; 
    } 
}; 

class DerivedB : public Base 
{ 
private: 
    //specific B member variables 
public: 
    DerivedB() : Base() {} 
    virtual void doStuff() { 
     std::cout << "Derived Class B - Do Stuff" << std::endl; 
    } 
}; 
int main() { 
    // your code goes here 
    std::vector<std::unique_ptr<Base> > container; 
    container.push_back(std::make_unique<DerivedA>()); 
    container.push_back(std::make_unique<DerivedB>()); 

    std::for_each(container.begin(), container.end(),[](std::unique_ptr<Base> & b) { 
     b->doStuff(); 
    }); 
    return 0; 
} 

現場演示here。