wie findet ihr diese Klasse?

[otze]

so nach ner stunde der muße und reflektion des problems(besser: schreiben des Algorithmus), wurde diese Klasse fertig.Ich persönlich finde sie sehr gelungen, zuerst wird ein ziemlich einfacher Allocator definiert, der eigentlich "nix" macht ausser auf einen speicherbereich aufzupassen, darunter folgt ein Manager für diesen Allocator,der eigentlich auch nich wieder viel macht, ausser eine map die diesen Allocator enthält zu verwalten.

Ich habe versucht mich bei den Ausdrücken ganz ans Englische zu halten, und nur C++ syntax zu verwenden, ma schaun obs was bringt

Was ich gerne hätte ist eure Meinung,und vielleicht ein Auge auf etwaige Fehler, der Bcb hat mich bei templates schon einmal hängen lassen.

namespace Virtual{
    //...
    //Allocator class
    template<class T>
    class VirtualAllocator{
        private:
            const int size;
            T* pointer;
        public:
             VirtualAllocator(int _size):size(_size){
                pointer=reinterpret_cast<T*>(malloc(size));
                if(pointer==NULL){
                    throw BaseFailure("Couldnt alloc memory","Virtual Allocator->ctor");
                }
            }
            ~VirtualAllocator(){
                free(reinterpret_cast<void*>(const_cast<T*>(pointer)));
            }
            T* getPointer(){
                return pointer;
            }
             int getSize() const{
                return size;
            }
            //operatoren
            T* operator ->(){
                return pointer;
            }
            T operator=(T data){
                *pointer=data;
                return *pointer;
            }
            bool operator==(T operand){
                if(*pointer==operand){
                    return true;
                }
                return false;
            }
    };
    //AllocatorManager
    template<class key,class Allocator=VirtualAllocator<char> >
    class AllocatorContainer{
        private:
            std::map<key,Allocator> Container;
        public:
            Allocator& getAllocator(key& Key){//return searched Allocator
                std::map<key,Allocator>::iterator pos=Container.find(Key);
                if(pos==Container.end()){
                    //exception fehlt noch
                }
                return pos->second;
            }
            Allocator& insert(key Key,int size){//adds a Allocator
                Container.insert(std::pair<key,Allocator>(Key,Allocator(size)));
                std::map<key,Allocator>::iterator pos=Container.find(Key);
                return pos->second;
            }
            void erase(key Key){//deletes an Allocator
                Container.erase(Container.find(Key));
            }
            void clear(){//deletes all Allocators
                Container.clear();
            }
    };    //missing:manager which allocates space using Allocators with the size of 4kb 
}

[Shlo]

der Begriff Element-Initialisierer ist dir bekannt, oder? Da malloc einen void-Pointer zurückgibt, reicht auch ein static_cast. Im Dtor der VirtualAllocator-Klasse ist der Cast sinnlos. Und was spricht gegen const std::string& ?

[Shlo]

nochwas:

int& getSize() const{
                return size;
            }
T* returnPointer() const{
                return pointer;
}

die obigen Zeilen sind illegal, denn du gibst ein konstantes Objekt zurück. Eine implizite Konvertierung gibt es hier nicht und sollte gar nicht kompilierbar sein.

[Gast]

operator= und Copy-Konstruktor redefinieren und ggf. verbieten.

bool operator<(VirtualAllocator){ 

            }

Das sollte eigentlich auch nicht compilierbar sein.

[Shlo]

Allocator& insert(std::string Key,int size){//adds a Allocator
                Container.insert(pair<key,Allocator>(Key,Allocator(size)));
            }

das auch nicht, der Rückgabewert fehlt

[tag]

Shlo schrieb:

...
T* returnPointer() const{
                return pointer;
}

die obigen Zeilen sind illegal, denn du gibst ein konstantes Objekt zurück.
...

Nö. returnPointer ist nicht illegal, denn nur pointer ist const, nicht aber *pointer.

[Shlo]

tag schrieb:

Nö. returnPointer ist nicht illegal, denn nur pointer ist const, nicht aber *pointer.

Der this-Zeiger hat in einer const-Methode den Typ const T* const. Und wo soll jetzt *pointer nicht const sein?

[otze]

*hust*
wo war meine Konzentration?
und wieso hat der bcb nicht gemeckert?

najo hab geupdated.Danke an alle.
wie gefällt euch denn die Klasse von der idee bzw vom Aufbau her?

[groovemaster]

Für Grössenangaben bei Speicherbereichen nutze ich normaleweise size_t. sizeof() liefert letztendlich auch size_t. Momentan ist das wohl eher Geschmackssache, für zukünftige 64 bit Anwendungen könnte das aber anders aussehen.
Für was brauchst du eigentlich so einen Allokator? Ich hab den Code nur mal schnell überflogen. Du verwendest eine map, scheint mir irendwie Verschendung von Ressourcen zu sein, kann mich da aber auch täuschen.

[Mis2com]

Wieso nutzt du malloc/free und nicht new/delete?
Ist das bei einer Allocaterklasse etwa ungültig?

[otze]

das prinzip ist folgende:
es geht um mein schon sehr sehr leidiges problem des mapen einer datei in den speicher,alle meine vorherigen versionen waren nicht flexibel genug, um sie "überall" wo sie sie gebraucht werden nutzen zu können.

mithilfe der containerklasse löse ich dieses problem:
ich kann den container mit string als key instantiieren, und somit wenn ich eine file lade ihren namen direkt als schlüssel nehmen,dh ich kann umgangsprachlich sagen: registriere mir auf den namen "image.jpg" 20kb speicher.
Durch die templates nehm ich Klassen die diese Klasse hier benutzen eine große menge arbeit ab-sie müssen sich nichtmehr um die key speicherung kümmern, und somit dürfte ich keine große Speicherplatzverschwendung haben.

wieso ich kein new/delete verwende? malloc scheint erstmal ähnlich schnell zu sein wie new/delete,ist aber für meine Zwecke erstmal viel einfacher.
achja, sowohl new/delete als auch malloc sind erlaubt(meinen allocator könnte man als "raw" bezeichnen.
//edit

so nach en bissl coden ist nun sowas möglich:

struct Vector3{
    float a;
    float b;
    float c;

    bool operator==(Vector3 operand){
        if(a==operand.a&&b==operand.b&&c==operand.c){
            return true;
        }
        return false;
    }
};
void test(){
    Virtual::AllocatorContainer<int,VirtualAllocator<Vector3> > container;
    container.insert(10,sizeof(Vector3)).getSize();
    int Key=11;
    container.insert(Key,sizeof(Vector3))->a=5;
    Vector3 test;
    if(container.getAllocator(Key)==test){
        //mach was
    };
    container.erase(10);
    container.clear();
}

[tag]

Shlo schrieb:

tag schrieb:

Nö. returnPointer ist nicht illegal, denn nur pointer ist const, nicht aber *pointer.

Der this-Zeiger hat in einer const-Methode den Typ const T* const. Und wo soll jetzt *pointer nicht const sein?

Der this-Zeiger ist in der Tat const T* const. Die Membervariable pointer wird aber nur von "U*" zu "U*const" und nicht etwa zu "const U* const" oder gar "const U*". Das const hinter der Funktion verhindert doch nur, dass sich *this ändert (also z.B. dass der Wert von pointer geändert wird), aber es wird nicht verhindert, dass sich der Wert, auf den pointer zeigt, sich ändert.

[Gast]

Das const hinter der Funktion verhindert doch nur, dass sich *this ändert (also z.B. dass der Wert von pointer geändert wird), aber es wird nicht verhindert, dass sich der Wert, auf den pointer zeigt, sich ändert.

Nein. this ist immer T* const und durch das const hinter der Funktion wird der Zeiger zu const T* const.

[Shlo]

tag schrieb:

Shlo schrieb:

tag schrieb:

Nö. returnPointer ist nicht illegal, denn nur pointer ist const, nicht aber *pointer.

Der this-Zeiger hat in einer const-Methode den Typ const T* const. Und wo soll jetzt *pointer nicht const sein?

Der this-Zeiger ist in der Tat const T* const. Die Membervariable pointer wird aber nur von "U*" zu "U*const" und nicht etwa zu "const U* const" oder gar "const U*". Das const hinter der Funktion verhindert doch nur, dass sich *this ändert (also z.B. dass der Wert von pointer geändert wird), aber es wird nicht verhindert, dass sich der Wert, auf den pointer zeigt, sich ändert.

Wo hast du den Schwachsinn her?

[tag]

Habe ich jemals etwas anderes behauptet? Es geht hier doch nicht um this, es geht hier um pointer (jedenfalls aus der Version von gestern Abend, als es noch

class VirtualAllocator{
...
    T* pointer;

hieß).

Ich meine:

class C
{
char* pointer;
char* returnPointer() const
{
return pointer;
}
};

ist legal, da zwar this ein const Cconst ist, aber this->pointer nicht const char const, sondern char*const ist.

[tag]

Shlo schrieb:

Wo hast du den Schwachsinn her?

Im Stroustrup unter Sektion 10.2.7.2 ist ein recht ähnliches Beispiel abgedruckt.

[otze]

wenn pointer const sind, werden die objekte auf die der pointer zeigt automatisch auch const,btw,hab den code wiedermal geändert, gibtn paar operatoren und 1-2 fehler wurden entfernt.
habs getestet, funzt wie ne eins,ist relativ schnell, und einfach zu handlen...was will man mehr?

[Gast]

wenn pointer const sind, werden die objekte auf die der pointer zeigt automatisch auch const

Nein. Tut mir leid, das stimmt einfach nicht. Was will man mehr?

[Shlo]

tag schrieb:

Shlo schrieb:

Wo hast du den Schwachsinn her?

Im Stroustrup unter Sektion 10.2.7.2 ist ein recht ähnliches Beispiel abgedruckt.

OK, bevor du weiter den Schwachsinn verbreitest solltest du genauer nachlesen: im 10.2.7.2 geht es mutable und das Beispiel sieht folgend aus:

struct cache
{
	//...
	std::string rep;
};

class Datum
{
public:
	std::string stringRep() const
	{
		return p->rep;
	}

private:
	cache* p;
};

Wo ist es denn ähnlich?

[otze]

Optimizer schrieb:

wenn pointer const sind, werden die objekte auf die der pointer zeigt automatisch auch const

Nein. Tut mir leid, das stimmt einfach nicht. Was will man mehr?

habs getestet,deshalb musste ich ja das const vor dem pointer wieder wegmachen.
ein T* GetPointer() const; konnte den pointer nicht zurückgeben, erst ein
const T* GetPointer() const; ließ das zu.
das hatte aber die wirkung, dass

GetPointer->a=5;

nicht funktioniert hat,weil ich keine const Objekte verändern darf(aufjedenfall sagt mir das der bcb)

[Shlo]

Wie wärs mit

T& operator=(const T& data)
{
	return *pointer=data;
}

bool operator==(const T& operand) const
{
	return *pointer==operand;
}