array of void*



  • Hallo,

    in einer Klasse, die verschiedenen anderen Klassen Speicher geben kann, möchte ich mir den this Pointer der jeweiligen anderen Klasse merken.

    Also hab ich ein Member void* owner[BlockCount];

    An anderer Stelle hab ich nun:

    for(MemSize_t i=0; i<BlockCount; ++i)
        {
            if(owner[i]==0) //<<-- hier schreit der Compiler
            {
                memBlock.memPointer=memory[i];
                memBlock.memSize=BlockSize;
                return memBlock;
            }
        }
    

    Fehler: error: ‘void’ is not a pointer-to-object type|*



  • zwingt mich C++ dazu, Pointer auf die Basisklasse zu speichern?
    Ist es also nicht wie in C möglich, einfach nur void* Zeiger zu verwenden, wenn ich mir einfach nur die Adresse merken möchte?



  • Natürlich, void enthält auch keine Typinformation. Lass mal void auf deutsch übersetzten. Was hast du eigentlich vor. Außerdem solltest du dir mal die Unterschiede zwischen Klassen und Objekten anschauen. 😉


  • Mod

    Da der Compiler immer recht hat, ziehe ich mal deine Aussage "Also hab ich ein Member void* owner[BlockCount];" in Zweifel.

    Ist es also nicht wie in C möglich, einfach nur void* Zeiger zu verwenden, wenn ich mir einfach nur die Adresse merken möchte?

    Doch, klar geht das.



  • Klasse/Objekt ist schon klar, hab mich unsauber ausgedrückt.

    Schreibe eine String Klasse die ohne new/delte auskommt.
    Dafür hab ich dann eine Klasse MemoryManagement, als SingleTon, welche mir aus einem Array einen Speicherblock gibt, und mitprotokoliert, von welcher String Instanz der Speicherblock verwendet wird.

    Will ein String Speicher, so macht er
    MemoryManagement.Instance().getMemory(this,Speichergröße in byte);
    Im DTOR wiederum sagt er dann MemoryManagement.Instance().releaseMemory(this);

    Anhand der this Zeiger weiß mein MemoryManagement welcher Speicher nun wieder frei wird, da sie in einer Tabelle protokolliert wer gerade welchen Speicher besitzt. Und um unabhängig zu bleiben, hätte ich halt void* owner[MAX] verwendet um die this Zeiger der Strings zu speichern.

    Kann natürlich auch eine Basisklasse einführen, aber dann ist die "lose Kopplung" nicht mehr ganz so lose!
    Ich würde ja niemals einen void* dereferenzieren, sondern es reicht mir zu wissen welche Adresse das ist. Daher wunderts mich dass C++ das verbietet.



  • kommando zurück, ich depp hab einen Funktionsparameter mit dem gleichen Namen, nämlich owner...

    Sry für die Verschwendung eurer Lebenszeit 🙄



  • void* ist in C++ böse, da es das strenge Typsystem unterläuft. Warum machst du aus der MemoryManage Klasse nicht ein Template? Nach dem Motto

    template<class T> class MemoryManagement {T* owner;};
    


  • Der Tobi schrieb:

    void* ist in C++ böse, da es das strenge Typsystem unterläuft. Warum machst du aus der MemoryManage Klasse nicht ein Template? Nach dem Motto

    template<class T> class MemoryManagement {T* owner;};
    

    naja dann hab ich aber mehrere Typen (MemoryManagement<KlasseA>, MemoryManagement<KlasseB> ), und somit auch mehrmals mein statisches Array m_Memory, welches aber nur einmal vorkommen soll. Ich umgehe damit gewissermaßen das, was ich mit dem Singleton erreichen möchte!

    Solange ich nichts mit den Zeigern mache, außer dass ich mir die Adresse als eindeutige ID des Speicher-Besitzers merken möchte, finde ich void* nicht so böse.
    Sobald ich dann aber sowas in der Art mache m_Owner[i]->FunktionXY(), ist natürlich der Weg mit den Basisklassenzeigern vorzuziehen.



  • Ich umgehe damit gewissermaßen das, was ich mit dem Singleton erreichen möchte!

    Nicht direkt, denn du hast das Array dann zwar mehrmals, aber für jeden Typen doch nur einmal und das ist mMn kein Unterlaufen deines Systems sondern eine Verbesserung.
    Außerdem: warum ein Array? Sollte sich die Anzahl an Basisklassenzeigern nicht verändern können, wenn jemand Speicher anfordert bzw. wieder freigibt?

    Wenn ich mich nicht irre, sollte das klappen:

    template<class T>
    class MemoryManagement
    {
        static vector<T*> _reserved; //Ich glaub vector<pointer> ist böse,
                                     //hab aber ptr_container grad nicht zur Verfügung
        static MemoryManagement* _instance;
    
        public:
    
            MemoryManagement* get_instance()
            {
                if (_instance == nullptr)
                    return (_instance = new MemoryManagement);
    
                return _instance;
    
            }
    };
    template<class T>
    MemoryManagement<T>* MemoryManagement<T>::_instance = nullptr;
    


  • Hallo,

    es geht darum, ohne new/delete auszukommen. Der von dir eingebaute vector verwendet aber genau das - nämlich new/delete.
    Ist für ein recht schwaches System. Ich möchte mir aber trotzdem ein bisschen was von dem C++ Luxus einbauen, den ich sonst von std::string gewohnt bin.


Log in to reply