spieleprogrammierer.de - Forum und Wiki zur Spieleprogrammierung und Spieleentwicklung

C-/C++-Quelltext

template <class T> class SecureStack
{   
    struct Entity
    {
        T       val;
        Entity* next;

        Entity(T _val) : val(_val), next(0) { }
        ~Entity()                           { }
    };
    Entity* Head;

    SecureStack(const SecureStack&)         { }//forbitten

    void operator = (const SecureStack&)    { }//forbitten


public:
    class ReturnType
    {
        Entity* pointer;

    public:
        ReturnType(void) : pointer(0)       { }
        ReturnType(Entity* e) : pointer(e)  { }
        ReturnType(ReturnType& e)           { pointer = e.pointer; e.pointer = 0; }
        ~ReturnType()                       { delete pointer; }
        bool operator = (ReturnType& e)     { delete pointer; pointer = e.pointer; e.pointer = 0; return (pointer != NULL); }
        T& operator*(void)                  { return pointer->val; }
        T* operator ->(void)                { return &pointer->val; }
    };

    SecureStack(void) : Head(0) { }
    ~SecureStack()              { while(Head) { Entity* p = Head; Head = Head->next; delete p; } }
    

    bool empty(void) const      { return (Head == 0); }

    bool getAll(std::list<T> &list)
    {
        //wir ersetzen Head  einfach gegen NULL und behalten Head

#pragma warning( disable: 4312)
#pragma warning( disable: 4311)
        Entity* oldH = (Entity*)InterlockedExchangePointer((void**)&Head, NULL);
#pragma warning( default: 4312)
#pragma warning( default: 4311)
        
        while(oldH)
        {
            list.push_front(oldH->val);
            Entity* h = oldH;
            oldH = oldH->next;
            delete h;
        }
        return true;
    }

    ReturnType pop(void) //not very fast

    {
        Entity* h = Head; 
        if(!h) return NULL;

        //auch wenn h ungültig werden sollte, so gibt es keinen Segfault, 

        //weil h->next ohne Zeigerverscheibung abläuft,

        //welche zum Absturz führen würden


        //wir tauschen Head und seinen Nachfolger einfach aus und behalten Head

        Entity* oldH = (Entity*)InterlockedCompareExchangePointer((void**)&Head, h->next, h);

        if(oldH != h)   return 0; //da hat einer dazwischengefunkt

        else            return oldH;//alles i.o.

    }

    void push(const T &val) 
    {
        Entity* oldH, *h;
        Entity* n = new Entity(val);
        
        do
        {
            h       = Head;
            n->next = h;
            oldH    = (Entity*)InterlockedCompareExchangePointer((void**)&Head, n, h);
        }while(oldH != h);
    }   
};