C++ niebezpieczne obejście obsada

Question

W złożonym kodzie, to ma szereg niewirtualny klasy bazowej wskaźnik (klasa podstawa ma żadnych metod wirtualnych)

Rozważmy kod:

#include <iostream> 

using namespace std; 

class TBase 
{ 
    public: 
     TBase(int i = 0) : m_iData(i) {} 
     ~TBase(void) {} 

     void Print(void) {std::cout << "Data = " << m_iData << std::endl;} 

    protected: 
     int  m_iData; 
}; 

class TStaticDerived : public TBase 
{ 
    public: 
     TStaticDerived(void) : TBase(1) {} 
     ~TStaticDerived(void) {} 
}; 

class TVirtualDerived : public TBase 
{ 
    public: 
     TVirtualDerived(void) : TBase(2) {} 
     virtual ~TVirtualDerived(void) {} //will force the creation of a VTABLE 
}; 

void PrintType(TBase *pBase) 
{ 
    pBase->Print(); 
} 

void PrintType(void** pArray, size_t iSize) 
{ 
    for(size_t i = 0; i < iSize; i++) 
    { 
     TBase *pBase = (TBase*) pArray[i]; 
     pBase->Print(); 
    } 
} 


int main() 
{ 
    TBase b(0); 
    TStaticDerived sd; 
    TVirtualDerived vd; 

    PrintType(&b); 
    PrintType(&sd); 
    PrintType(&vd); //OK 

    void* vArray[3]; 
    vArray[0] = &b; 
    vArray[1] = &sd; 
    vArray[2] = &vd; //VTABLE not taken into account -> pointer not OK 
    PrintType(vArray, 3); 

    return 0; 
} 

wyjście jest (przygotowane z Mingw-W64 GCC 4.9.2 na Win64)

Data = 0 
Data = 1 
Data = 2 
Data = 0 
Data = 1 
Data = 4771632 

przyczyną niepowodzenia jest to, że każde wystąpienie TVirtualDerived ma wskaźnik do tablicy wirtualnej, która nie ma TBase. Tak więc up-casting do TBase bez wcześniejszej informacji o typie (od void * do TBase *) nie jest bezpieczny.

Chodzi o to, że w pierwszej kolejności nie mogę uniknąć rzucania w pustkę. Dodanie metody wirtualne (destructor na przykład) na prace klasy bazowej, ale kosztem pamięci (które chcę uniknąć)

Kontekst:

wdrażamy system sygnał/gniazda, w bardzo ograniczone środowisko (pamięć poważnie ograniczona). Ponieważ mamy kilka milionów obiektów, które mogą wysyłać i odbierać sygnały, ten rodzaj optymalizacji jest skuteczne (jeśli to działa, oczywiście)

Pytanie:

Jak mogę rozwiązać ten problem? Do tej pory znalazłem:

1 - dodać wirtualną metodę w TBase. Działa, ale tak naprawdę nie rozwiązuje problemu, unika go. I jest to nieefektywne (za dużo pamięci).

2 - rzutowanie na TBase * zamiast rzucania do pustki * w układzie, kosztem utraty ogólności. (prawdopodobnie to, co spróbuję dalej)

Czy widzisz inne rozwiązanie?

Answer 1

Musisz zastanowić się, w jaki sposób klasa jest umieszczona w pamięci. TBase jest łatwe, to tylko cztery bajty z jednego elementu:

_ _ _ _ 
|_|_|_|_| 
^ 
m_iData 

TStaticDerived jest taka sama. Jednak TVirtualDerived jest zupełnie inny. Ma teraz przyrównanie 8 i musi zacząć się przód z vtable, zawierający pozycje dla destructor:

_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_|_| 
^    ^
vtable   m_iData 

Więc kiedy rzucasz vd do void* a następnie TBase*, jesteś skutecznie reinterpretacji pierwsze cztery bajty twojego vtable (adres przesunięcia do ~TVirtualDerived()) jako m_iData. Rozwiązaniem jest najpierw zrobić static_cast do TBase*, która zwraca wskaźnik do skorygowania początkowy punkt TBase w vd i następnie do void*:

vArray[2] = static_cast<TBase*>(&vd); // now, pointer is OK 

Answer 2

Problem jest w rzucasz. Podczas korzystania z odlewu typu C przez pustą, jest to odpowiednik reinterpret_cast, który może być słaby przy podklasowaniu. W pierwszej części typ jest dostępny dla kompilatora, a twoje rzuty są równoważne static_cast.

Ale nie rozumiem, dlaczego mówisz, że nie można uniknąć przesyłania do unieważnienia * w pierwszej kolejności. Jako PrintType wewnętrznie konwertuje void * na TBase *, można równie dobrze przekazać TBase **. W tym przypadku będzie to działać dobrze:

void PrintType(TBase** pArray, size_t iSize) 
{ 
    for(size_t i = 0; i < iSize; i++) 
    { 
     TBase *pBase = pArray[i]; 
     pBase->Print(); 
    } 
} 
... 
    TBase* vArray[3]; 
    vArray[0] = &b; 
    vArray[1] = &sd; 
    vArray[2] = &vd; //VTABLE not taken into account -> pointer not OK 
    PrintType(vArray, 3); 

Ewentualnie, jeśli chcesz użyć void ** tablicę, trzeba jawnie upewnić, że to, co można umieścić w nim są tylko TBase *a nie wskaźnik do podklasy:

void* vArray[3]; 
vArray[0] = &b; 
vArray[1] = static_cast<TBase *>(&sd); 
vArray[2] = static_cast<TBase *>(&vd); 
PrintType(vArray, 3); 

Ci zarówno sposób prawidłowo Wydajność:

Data = 0 
Data = 1 
Data = 2 
Data = 0 
Data = 1 
Data = 2 

Answer 3

Zapomnij o wirtualnym polimorfizmie. Zrób to w staroświecki sposób.

Dodaj jeden bajt do każdego zwarcia, aby wskazać typ i instrukcję przełącznika w metodzie drukowania na "Zrób właściwą rzecz". (oszczędza to sizeof (wskaźnik) -1 bajtów na TBase w stosunku do metody wirtualnej:

Jeśli dodanie bajtu jest nadal zbyt kosztowne, rozważ użycie pól bitowych C/C++ (każdy pamięta te (uśmiech)), aby wycisnąć wpisz pole do innego pola, które nie wypełnia dostępnej przestrzeni (na przykład niepodpisana liczba całkowita, która ma maksymalną wartość 2^24 - 1)

Twój kod będzie brzydki, prawdziwy, ale twoje surowe ograniczenia pamięci są Brzydki kod działa lepiej niż piękny kod, który się nie powiódł