代码回顾

Posted 2020-09-08 琴鸟

 

1.继承和多态，多线程

做棋牌demo的时候，基本模型都是事件轮询，每个事件一个线程。

所以做了一个基类和派生类。使用了常见的功能。

有几个基础知识点

1.派生类访问基类public方法：基类：：方法名字  ，如。IEventLoop::Close();

2.派生类的构造函数不指定，会调用默认的基类构造函数。也可以指定,如 Loop_Log()：IEventLoop（）{}

3.派生类的构造顺序，基类默认构造，派生类构造。   而派生类析构，是相反，派生类析构，基类析构。

4.vecotr<t>，析构的时候会调用元素的析构函数，如果是原始指针类型，那么只是free 掉指针而已。如果是对象，那么必定会调用元素的析构函数。所以感觉  class EventsMgr的数据成员用vector<shared_ptr<t>>,会更好，这样，使用者

就不用考虑析构的问题，让使用者能更自然使用new.到堆中。

 5.如果要制定顺序关闭服务器。只需要更改下EventsMgr的close 函数。逐个判断是否关闭。

#include <iostream>
#include "stdio.h"
#include <memory>
#include <unistd.h>
#include <thread>
#include <vector>

using namespace std;


class IEventLoop
{
public:
    IEventLoop():shouldloop(true),stop(false){}
    virtual void Start()=0;
    bool IsStart()
    {
        return shouldloop;
    }
    virtual void Close()
    {
        shouldloop=false;
    }
    bool IsClosed()
    {
        return stop;
    }
    
    virtual ~IEventLoop(){}
protected:
    bool shouldloop;
    bool stop;
};


class Loop_Log:public IEventLoop
{
public:
    Loop_Log(){}
    void Start()
    {
        while(shouldloop)
        {
            cout<<"log is runing"<<endl;
            sleep(1);
        }
        stop=true;
    }
    
    void Close()
    {
        IEventLoop::Close();
        cout<<"log is closed"<<endl;
    }
    
    ~Loop_Log()
    {
        int a=3;
    }
};


class Epollserver:public IEventLoop
{
public:
    Epollserver(){}
    void Start()
    {
        while(shouldloop)
        {
            cout<<"epollserver is runing"<<endl;
            sleep(1);
        }
        stop=true;
    }
    
    void Close()
    {
        IEventLoop::Close();
        cout<<"epollserver is closed"<<endl;
    }
    
    ~Epollserver()
    {
        int a=3;
    }
};

class EventsMgr
{
public:
    void AddEvent(IEventLoop* _event)
    {
        if(_event!=0)
        {
            events.push_back(_event);
        }
    }
    void Start()
    {
        for(size_t i=0;i<events.size();++i)
        {
            auto lamfun=[](IEventLoop* pi){ pi->Start();};
            thread logthread=thread(lamfun,events[i]);
            logthread.detach();
        }
    }
    
    void Close()
    {
        bool allexist=false;

        for(size_t i=0; i<events.size(); ++i)
        {
            if (events[i]!=0x0)
            {events[i]->Close();}
        }
        while(!allexist)
        {
            allexist=true;

            for(size_t i=0; i<events.size(); ++i)
            {
                if(events[i]->IsClosed()==false)
                {
                    allexist=false;
                    break;
                }
            }
        }
    }
private:
    vector<IEventLoop*> events;
};




int main()
{
    EventsMgr mymgr;
    
    Loop_Log mylog;
    mymgr.AddEvent(&mylog);
    
    //vector<Loop_Log> test;
    //test.push_back(mylog);
    
    Epollserver myserver;
    mymgr.AddEvent(&myserver);
    
    mymgr.Start();
    
    string cmd;
    cin>>cmd;
    
    while(cmd=="88")
    {
        mymgr.Close();
        break;
    }
    
    
}

 修改后vector元素为共享指针。

#include <iostream>
#include "stdio.h"
#include <memory>
#include <unistd.h>
#include <thread>
#include <vector>

using namespace std;


class IEventLoop
{
public:
    IEventLoop():shouldloop(true),stop(false){}
    virtual void Start()=0;
    bool IsStart()
    {
        return shouldloop;
    }
    virtual void Close()
    {
        shouldloop=false;
    }
    bool IsClosed()
    {
        return stop;
    }
    
    virtual ~IEventLoop(){}
protected:
    bool shouldloop;
    bool stop;
};


class Loop_Log:public IEventLoop
{
public:
    Loop_Log():IEventLoop(){}
    void Start()
    {
        while(shouldloop)
        {
            cout<<"log is runing"<<endl;
            sleep(1);
        }
        stop=true;
    }
    
    void Close()
    {
        IEventLoop::Close();
        cout<<"log is closed"<<endl;
    }
    
    ~Loop_Log()
    {
        int a=3;
    }
};


class Epollserver:public IEventLoop
{
public:
    Epollserver(){}
    void Start()
    {
        while(shouldloop)
        {
            cout<<"epollserver is runing"<<endl;
            sleep(1);
        }
        stop=true;
    }
    
    void Close()
    {
        IEventLoop::Close();
        cout<<"epollserver is closed"<<endl;
    }
    
    ~Epollserver()
    {
        int a=3;
    }
};

class EventsMgr
{
public:
    void AddEvent(shared_ptr<IEventLoop> _event)
    {
        if(_event!=0)
        {
            events.push_back(_event);
        }
    }
    void Start()
    {
        for(size_t i=0;i<events.size();++i)
        {
            auto lamfun=[](shared_ptr<IEventLoop> pi){ pi->Start();};
            thread logthread=thread(lamfun,events[i]);
            logthread.detach();
        }
    }
    
    void Close()
    {
        bool allexist=false;

        for(size_t i=0; i<events.size(); ++i)
        {
            if (events[i]!=0x0)
            {events[i]->Close();}
        }
        while(!allexist)
        {
            allexist=true;

            for(size_t i=0; i<events.size(); ++i)
            {
                if(events[i]->IsClosed()==false)
                {
                    allexist=false;
                    break;
                }
            }
        }
    }
private:
    vector<shared_ptr<IEventLoop> > events;
};


int main()
{
    EventsMgr mymgr;
    
    mymgr.AddEvent(shared_ptr<IEventLoop>(new Loop_Log()));
    mymgr.AddEvent(shared_ptr<IEventLoop>(new Epollserver()));
    
    mymgr.Start();
    
    string cmd;
    cin>>cmd;
    
    while(cmd=="88")
    {
        mymgr.Close();
        break;
    }
}