spieleprogrammierer.de - Forum und Wiki zur Spieleprogrammierung und Spieleentwicklung

C-/C++-Quelltext

class CSceneNode
{
protected:
    //members
    
    //Array of Children...
    CSceneNode      **ppChildren;
    int             iChildrenCount;

    //primitive
    IIntersectable  *pData;


    //recursive functions
    CSceneNode* Copy(CSceneNode *node)
    {
        CSceneNode *res = new CSceneNode();

        //copy data directly

        //....todo
        res->Data = node->Data;
        res->iChildrenCount = 0;
        res->ppChildren = NULL;
        
        //is node leaf?
        if(!node->isLeaf())
        {
            //traverse SceneNode
            res->ppChildren = new CSceneNode*[node->iChildrenCount];
            res->iChildrenCount = node->iChildrenCount;
            //alle Kinder kopieren
            for(int i = 0; i < node->iChildrenCount; i++)
            {
                res->ppChildren[i] = Copy(node->ppChildren[i]);
            }
        }   
        return res;
    }

    void printR(CSceneNode *node, int level)
    {
        std::cout<<"Value is "<<node->Data<<" on level "<<level<<std::endl;
        if(!node->isLeaf())
        {
            for(int i = 0; i < node->iChildrenCount; i++)
                printR(node->ppChildren[i], level + 1);
        }
    }

    CSceneNode* clear(CSceneNode *node)
    {
        //is Leaf?
        if(node->isLeaf())
        {
            //only delete Data 
            //and then delete Pointer
            SAFE_DELETE(node->pData);
            //delete node himself!
            SAFE_DELETE(node);

            //node should be NULL!
            if(node != NULL)std::cout<<"Bad error!"<<std::endl;

            //done!
            return NULL;
        }
        else
        {
            //this is no leaf, so delete its children
            for(int i = 0; i < node->iChildrenCount; i++)
            {
                node->ppChildren[i] = clear(node->ppChildren[i]);

                //child shall be NULL!
                if(node->ppChildren[i] != NULL)std::cout<<"Bad error!"<<std::endl;

                //deleted...
            }

            //so now delete array of pointers!
            SAFE_DELETE_A(node->ppChildren);
            node->iChildrenCount = 0;

            //array shall be NULL!
            if(node->ppChildren != NULL)std::cout<<"Bad error!"<<std::endl;

            //secure NULL!
            node->ppChildren = NULL;

            //delete Node Data, and Node himself!
            SAFE_DELETE(node->pData);
            //delete node himself!
            SAFE_DELETE(node);

            //node should be NULL!
            if(node != NULL)std::cout<<"Bad error!"<<std::endl;

            //done!
            return NULL;
        }
    }
public:
    int Data;

    //constructor
    CSceneNode()
    {
        ppChildren = NULL;
        iChildrenCount = 0;
        pData = NULL;
    }

    CSceneNode(int d)   {ppChildren = NULL; iChildrenCount = 0; Data = d; pData = NULL;}

    //destructor
    ~CSceneNode()
    {
        std::cout<<"dtor of "<<Data<<" with "<<iChildrenCount<<" children"<<std::endl;
        
        SAFE_DELETE(pData);

        for(int i = 0; i < iChildrenCount; i++)
        {
            SAFE_DELETE(ppChildren[i]);
        }
        iChildrenCount = 0;
        SAFE_DELETE_A(ppChildren);

        std::cout<<ppChildren<<std::endl;
            
        //Clear();
    }

    //make this SceneNode, a copy of another
    void        CopyOf(CSceneNode *node)
    {
        Data = node->Data;
        
        //is node leaf?
        if(node->isLeaf())
        {
            //copy data directly

            //....todo
            Data = node->Data;
        }
        else
        {
            //traverse SceneNode
            ppChildren = new CSceneNode*[node->iChildrenCount];
            iChildrenCount = node->iChildrenCount;

            //alle Kinder kopieren
            for(int i = 0; i < node->iChildrenCount; i++)
            {
                ppChildren[i] = Copy(node->ppChildren[i]);
            }
        }       
    }

    //add an element
    void        Append(CSceneNode& node)
    {
        //extend array
        CSceneNode **tmp = new CSceneNode*[iChildrenCount + 1];
        
        //copy array
        for(int i = 0; i < iChildrenCount; i++)
        {
            tmp[i] = ppChildren[i];
        }

        //delete old pointer
        SAFE_DELETE_A(ppChildren);
        
        //set node
        (tmp[iChildrenCount]) = new CSceneNode();

        if(!node.isLeaf())
        {
            CSceneNode _node = node;

            //*(tmp[iChildrenCount]) = node;
            tmp[iChildrenCount] = Copy(&_node);
        }
        else *(tmp[iChildrenCount]) = node;


        //inc count
        iChildrenCount++;

        //set pointer
        ppChildren = tmp;
    }

    void print()
    {
        printR(this, 0);
    }

    void    Clear()
    {
        //delete via clear!
        if(isLeaf())
        {
            //only delete Data 
            //and then delete Pointer
            SAFE_DELETE(pData);
                        
        }
        else
        {
            //this is no leaf, so delete its children
            for(int i = 0; i <iChildrenCount; i++)
            {
                ppChildren[i] = clear(ppChildren[i]);

                //child shall be NULL!
                if(ppChildren[i] != NULL)std::cout<<"Bad error!"<<std::endl;

                //deleted...
            }

            //so now delete array of pointers!
            SAFE_DELETE_A(ppChildren);
            iChildrenCount = 0;

            //array shall be NULL!
            if(ppChildren != NULL)std::cout<<"Bad error!"<<std::endl;

            //secure NULL!
            ppChildren = NULL;

            //delete Node Data, and Node himself!
            SAFE_DELETE(pData);
        }
    }

    //Helperfunction
    bool        isLeaf()    {return ppChildren == NULL; }
};

C-/C++-Quelltext

CSceneNode sub = CSceneNode(3);
    
sub.Append(CSceneNode(4));
sub.Append(CSceneNode(5));
    
CSceneNode top = CSceneNode(1);
top.Append(sub);

std::cout<<"exit<<std::endl;