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|*

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.

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.

Sry für die Verschwendung eurer Lebenszeit

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

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;

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.