RenderTree渲染树

RenderTree渲染树对类中的静态成员有很重要的关系，这个和多态是有很重要的关系，举个简单的例子，在游戏中，马里奥需要渲染，蘑菇也需要渲染，怪兽也需要渲染，其是串在一个树上的，但是不同的类型怎么将其挂在一起，在渲染的过程中，马里奥，蘑菇和怪兽都是拥有不同的渲染接口，但是这样渲染器会做的很复杂，并不是我们想要的，简单的方式就是创建一个抽象基类，让马里奥，蘑菇和怪兽都继承同一个抽象基类，但是我们面临的问题是，对于马里奥，蘑菇和怪兽来说，他们的类型都是不一样的，怎么才能够穿在一个链表上

如上所示，提供一个纯虚函数show，使得下面的函数可以继承，每个子类中的show都是不一样的

为了将这些东西连起来，需要有个静态的头，这个是没有问题的

要串成一个链表，我们要求所有的节点都是类型是一样的，所以需要在每个节点加上next，因此这个链表本质上是父类指针next连在一起的

#include <iostream>
using namespace std;

#include <thread>
#include <unistd.h>
//父类需要提供一个接口
class RenderShape
{
public:
    virtual void show()=0;
    bool init(int x,int y)
    {
        _x=x;
        _y=y;
        return true;
    }

    static void RenderShapeList()
    {
        RenderShape *t=head;
        while(t)
        {
            t->show();//所有的地方可以直接实现覆写
            t=t->next;
        }
    }

protected:
    int _x;
    int _y;
    static RenderShape *head;//这个是需要共享的
           RenderShape *next;
};

RenderShape *RenderShape::head=nullptr;

class Rect:public RenderShape
{
public:
    Rect *create(int x,int y,int w,int l)
    {
        Rect *pRet=new Rect;
        if(pRet&&pRet->init(x,y,w,l))
        {
            pRet->autoRelease();
        }
        else
        {
            delete pRet;
            pRet=nullptr;
        }
    }

    bool init(int x, int y,int w,int l)
    {
        RenderShape::init(x,y);
        _w=w;
        _l=l;
        return true;
    }

    void autoRelease()
    {
        this->next=head;
        head=this;
    }

    virtual void show()
    {
        cout<<"draw rect from"<<"("<<_x<<","<<")"<<_y
           <<"width"<<_w<<"length"<<_l<<endl;
    }
protected:
    int _w;
    int _l;
};

class Circle:public RenderShape
{
public:
    Circle *create(int x,int y,int r)
    {
        Circle *pRet=new Circle;
        if(pRet&&pRet->init(x,y,r))
        {
            pRet->autoRelease();
        }
        else
        {
            delete pRet;
            pRet=nullptr;
        }
    }

    bool init(int x, int y, int r)
    {
        RenderShape::init(x,y);
        _r=r;
        return true;
    }

    void autoRelease()
    {
        this->next=head;
        head=this;
    }

    virtual void show()
    {
        cout<<"draw circle from"<<"("<<_x<<","<<")"<<_y
           <<"radius"<<_r<<endl;
    }

protected:
    int _r;
};

class Ellipse:public RenderShape
{
protected:
    int _l;
    int _s;
};

void threadTask()
{
    while(1)
    {
        cout<<"++++++++++++++++++++++++++"<<endl;
        RenderShape::RenderShapeList();
        sleep(2);
        cout<<"--------------------------"<<endl;
    }
}
int main()
{
    Rect *pr;
    Circle *pc;

    thread t(threadTask);
    while(1)
    {
        int choice;
        cin>>choice;
        switch(choice)
        {
            case 1:
                pr=Rect::create(1,2,3,4);
                break;
            case 2:
                pc=Circle::create(4,5,6);
                break;
        }
    }
    t.join();
    return 0;
}