加深理解多态思想的C++程序

Demo

项目构成

1. 编译环境在C++11下、QT编辑器；
2. 案例包含有3个头问件和3个cpp，其中有一个工具类，实现了自定义的make_unique功能。
3. 文件解释： basicthread.h – 父类头文件, subclass.h – 子类头文件。

源代码

1. basicthread.h

#ifndef BASICTHREAD_H
#define BASICTHREAD_H
#include <vector>
#include <thread>
#include <tuple>
#include <map>
#include <bits/unique_ptr.h>
using namespace std;

namespace solitary {
namespace mythread {
//enable_if
template <bool B, class T = void>
using enable_if_t = typename enable_if<B, T>::type;

enum Type{
    Orange_,
    Ginko_,
    Apple_,
    Grape_,
};
enum Color{
    Yellow,
    White,
    Red,
    Blue,
};
class ThreadRunner{
public:
    ThreadRunner(Type type, float size, double price, Color color, uint16_t number);
    ThreadRunner(const ThreadRunner&) = default;
    ThreadRunner& operator=(const ThreadRunner&) = default;
    ~ThreadRunner() = default;
    virtual void runner() = 0 ;

protected://只能被类成员函数、子类函数及友元访问，不能被其他任何访问，本身的类对象也不行
    vector<string> _vtype = {"Orange", "Ginko", "Apple", "Grape"};
    Type type;
    float size;
    double price;
    Color color;
    uint16_t number;

};

class ThreadRegister{
public:
    ThreadRegister() = default;
    ~ThreadRegister() = default;
    void init();
    void RegisterInit();

    template <typename T>
    void Register(Type type, float size, double price, Color color, uint16_t number);
    void Run();
private:
    vector<unique_ptr<ThreadRunner>> _vrunners;
//    vector<tuple<Type, float, double, Color, uint16_t> > _vclassparams;
//    map<Type, string> _mtype;
};

class BasicThread
{
public:
    BasicThread();
    ~BasicThread() = default;
    void RegisterThread();
    void StarThread();
private:
    ThreadRegister threadregister;

};
}   //namespace solitary
}   //namespace mythread


#endif // BASICTHREAD_H

2. subclass.h

#ifndef SUBCLASS_H
#define SUBCLASS_H

#include "basicthread.h"
using namespace solitary::mythread;

class Apple : public ThreadRunner
{
public:
    Apple(Type type, float size, double price, Color color, uint16_t number);
    void runner() override;

};

class Ginko : public ThreadRunner
{
public:
    Ginko(Type type, float size, double price, Color color, uint16_t number);
    void runner() override;

};

class Orange : public ThreadRunner
{
public:
    Orange(Type type, float size, double price, Color color, uint16_t number);
    void runner() override;

};

class Grape : public ThreadRunner
{
public:
    Grape(Type type, float size, double price, Color color, uint16_t number);
    void runner() override;

};

class Test
{
public:
    Test(Type type, float size, double price, Color color, uint16_t number);
    void runner() ;

};


#endif // SUBCLASS_H

3. util.h

#ifndef UTIL
#define UTIL
#include <bits/unique_ptr.h>
#include "subclass.h"
namespace solitary {
namespace util {
using namespace std;
template<typename T, typename... Args>
unique_ptr<T> make_unique(Args&&... args)
{
    return unique_ptr<T>(new T(forward<Args>(args)...));
}
}	//namespace solitary
}	//namespace util

#endif // UTIL

4. basicthread.cpp

#include "basicthread.h"
#include "util.h"
#include <iostream>
using namespace solitary::mythread;
using namespace solitary::util;
BasicThread::BasicThread()
{
    threadregister.init();
    RegisterThread();
    //    StarThread();
}

void BasicThread::RegisterThread()
{
    threadregister.RegisterInit();
}

void BasicThread::StarThread()
{
    while(true)
    {
        threadregister.Run();
        this_thread::sleep_for(chrono::seconds(1));
    }
}

void ThreadRegister::init()
{
    _vrunners.clear();
//    _vclassparams.clear();
//    _mtype.clear();
//    _mtype.insert(make_pair<Type, string>(Type::Apple_, "Apple"));
//    _mtype.insert(make_pair<Type, string>(Type::Orange_, "Orange"));
//    _mtype.insert(make_pair<Type, string>(Type::Ginko_, "Ginko"));
//    _mtype.insert(make_pair<Type, string>(Type::Grape_, "Grape"));
}

void ThreadRegister::RegisterInit()
{
/*    _vclassparams.emplace_back(make_tuple<Type, float, double, Color, uint16_t>
                               (Type::Apple_, 12.3f, 4.12f, Color::Red, 20));
    _vclassparams.emplace_back(make_tuple<Type, float, double, Color, uint16_t>
                               (Type::Orange_, 21.3f, 14.12f, Color::Yellow, 35));
    _vclassparams.emplace_back(make_tuple<Type, float, double, Color, uint16_t>
                               (Type::Ginko_, 31.3f, 24.12f, Color::White, 60));
    _vclassparams.emplace_back(make_tuple<Type, float, double, Color, uint16_t>
                               (Type::Grape_, 5.3f, 6.12f, Color::Blue, 12));
#define GETPARAMES()\
    get<0>(t), get<1>(t), get<2>(t), get<3>(t), get<4>(t)\

    for(auto &t : _vclassparams)
    {
        Register<Apple>(GETPARAMES());
    }*/
    Register<Apple>(Type::Apple_, 12.3f, 4.12f, Color::Red, 20);
    Register<Orange>(Type::Orange_, 21.3f, 14.12f, Color::Yellow, 35);
    Register<Ginko>(Type::Ginko_, 31.3f, 24.12f, Color::White, 60);
    Register<Grape>(Type::Grape_, 5.3f, 6.12f, Color::Blue, 12);
//    Register<Test>(Type::Grape_, 5.3f, 6.12f, Color::Blue, 12);
}


template <typename T>
void ThreadRegister::Register(Type type, float size, double price, Color color, uint16_t number)
{
    _vrunners.emplace_back(move(
                               make_unique<enable_if_t<is_base_of<ThreadRunner, T>::value, T>>
                               (type, size, price, color, number))
                           );
}

void ThreadRegister::Run()
{
    for(auto& runner : _vrunners)
    {
        runner->runner();
    }
}

//runner
ThreadRunner::ThreadRunner(Type type, float size, double price, Color color, uint16_t number)
    :type(type), size(size), price(price), color(color), number(number)
{

}

5. subclass.cpp

#include "subclass.h"
#include <iostream>
#define CONSOLE(type, size, price, color, number)\
    cout << "Type: "    << _vtype[type]\
         << ", size: "  << size\
         << ", price: " << price\
         << ", color: " << color\
         << ", number: "  << number\
         << endl;\

Apple::Apple(Type type, float size, double price, Color color, uint16_t number)
    : ThreadRunner(type, size, price, color, number)
{

}

void Apple::runner()
{
    cout << "Apple -- " ;
    CONSOLE(type, size, price, color, number);
}

Ginko::Ginko(Type type, float size, double price, Color color, uint16_t number)
    : ThreadRunner(type, size, price, color, number)
{

}

void Ginko::runner()
{
    cout << "Ginko -- " ;
    CONSOLE(type, size, price, color, number);
}

Orange::Orange(Type type, float size, double price, Color color, uint16_t number)
    : ThreadRunner(type, size, price, color, number)
{

}

void Orange::runner()
{
    cout << "Orange -- " ;
    CONSOLE(type, size, price, color, number);
}

Grape::Grape(Type type, float size, double price, Color color, uint16_t number)
    : ThreadRunner(type, size, price, color, number)
{

}

void Grape::runner()
{
    cout << "Grape -- " ;
    CONSOLE(type, size, price, color, number);
}

void Test::runner()
{
    cout << "Test -----" << endl;
}

6. main.cpp

#include <iostream>
#include <basicthread.h>
using namespace std;
using namespace solitary::mythread;

int main()
{
    BasicThread basicthread;
    basicthread.StarThread();
    return 0;
}