Question

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

#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];
};

如您所见，此示例是关于将异步完成的任务或作业。想象一下，有一个Task的队列和一堆工作线程，可能是目标机器上每个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()，即使我处理指向基类的指针？

Answer 1

是：可以将指向基类的引用/指针隐式转换为派生类的指针/引用。这正是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();
};

打印：

哇，编译时解析多态！

Here是一个正在运行的例子。

派生类的成员在转换为基类时是否可以访问？

1 个答案: