0

我举了一个简单的例子来说明我的问题。这是基类。

#include <mutex>
#include <atomic>

class Task
{
public:
    Task()
    {
        Empty.store(true);
    }
    std::mutex Access;
    std::atomic<bool> Empty;
    virtual void Work() = 0;
};

这是派生类。

#include <stdlib.h>

class ExampleTask : public Task
{
public:
    void Work()
    {
        for(int i = 0; i < 16; ++i)
        {
            Data[i] = rand();
        }
    }
private:
    int Data[16];
};

如您所见，此示例是关于将异步完成的任务或作业。想象一下，有一个Tasks 队列和一堆工作线程，可能一个用于目标机器上的每个 CPU 核心。

任务队列存储投射到其基类的任务，以便工作线程可以从队列中获取下一个作业并调用Work().

std::list<Task*> Queue;

ExampleTask *example = new ExampleTask();
Queue.push_back((Task*)example);

然后，工作线程将获取第一个任务，将其从队列中删除，然后处理它。

while(true)
{
    Task *current = Queue.front();
    Queue.erase(Queue.begin());
    current->Work();
}

这个概念行得通吗？即使我处理指向基类的指针，也可以Data在调用时访问？current->Work()

4

1 回答 1

0

是：基类的引用/指针可以隐式转换为派生类的指针/引用。这正是CRTP和静态多态性的工作原理：

template<typename T>
struct CRTP_base
{
    void execute()
    {
        static_cast<T*>(this)->f(); //The instance is casted to the known derived class, and we use the derived class function f.
    }
};

struct Foo : public CRTP_base<Foo>
{
    void f()
    {
        std::cout << "Wow, compile-time resolved polymorphism!" << std::endl;
    }
};

int main()
{
   Foo my_foo_instance;
   CRTP_base<Foo>& base_reference = my_foo_instance;
   base_reference.execute();
};

这打印：

哇，编译时解决的多态性！

这是一个运行示例。

于 2013-08-07T12:37:25.177 回答