是否可以使用其基类构造函数创建派生类的指针而不修改派生类的布局？

Question

考虑这种布局：

#include <memory>
#include <vector>

struct data{};

struct task {
    data* data_ptr = nullptr;

    virtual void work() = 0;
};

struct special_task : task {

    void work() override { /*work with the data*/ }
};

task 可以访问数据。派生类必须实现它们各自的work() 例程。

现在task_collection 存储数据和任务指针向量，派生类的实例可以添加到该向量：

struct task_collection {
    data data;
    std::vector<std::unique_ptr<task>> tasks;

    template<typename T>
    void add() {
        this->tasks.push_back(std::make_unique<T>());
        this->tasks.back()->data_ptr = &this->data;
    }
};

int main() {
    task_collection t;
    t.add<special_task>();
}

现在这很好用。但是，我想知道是否可以将 data* data_ptr 替换为参考，因为它在这里似乎更合适，并且它也将许多 -> 替换为 .s

---

但是，如果不更改 special_task 的布局，似乎不可能实现这一点，因为引用需要基类 task 中的构造函数，而派生类会取消其基构造函数：

struct task {
    task(data& data) : data_ref(data){}
    data& data_ref;

    virtual void work() = 0;
};

struct special_task : task {

    void work() override { /*work with the data*/ }
};

struct task_collection {
    data data;
    std::vector<std::unique_ptr<task>> tasks;

    template<typename T>
    void add() {
        this->tasks.push_back(std::make_unique<T>(this->data)); //Error!
    }
};

它给出了这个错误：

Error   C2664   'special_task::special_task(const special_task &)': cannot convert argument 1 from 'data' to 'const special_task &'

我知道这可以通过添加来“解决”

using task::task;

到每个派生类，因为现在它找到了适当的构造函数。但这并不是真正的解决方案，因为可能有数百个派生类，由多人编写。如果using task::task; 的一个实例丢失，可能会导致头痛。额外的代码行也抵消了使用引用而不是指针带来的好处。

---

那么有没有办法将task::data_ref 实现为仅修改task_collection 或task 而没有任何派生类的引用？

Answer 1

ITNOA

如果问题的所有者可以接受一些时间使用get() 而不是. 来访问数据，他可以使用std::reference_wrapper 而不是原始引用来解决重新绑定问题。

#include <memory>
#include <vector>
#include <functional>

struct data{};

static data empty_data;

struct task {
    std::reference_wrapper<data> data_ptr = empty_data;

    virtual void work() = 0;
};

struct special_task : task {

    void work() override { /*work with the data*/ }
};

struct task_collection {
    data data;
    std::vector<std::unique_ptr<task>> tasks;

    template<typename T>
    void add() {
        this->tasks.push_back(std::make_unique<T>());
        this->tasks.back()->data_ptr = std::ref(this->data);
    }
};

int main()
{
    task_collection t;
    t.add<special_task>();
}

为了使用数据，你可以像下面这样表现

data temp_data = t.tasks.back()->data_ptr;

正如您在How to correctly use std::reference_wrappers 中看到的那样，std::reference_wrapper 类实现了一个隐式转换运算符到 T&:

constexpr operator T& () const noexcept;

所以当需要 T（或 T&）时调用隐式运算符，而您不需要使用 get() 函数，例如

void f(some_type x);
// ...
std::reference_wrapper<some_type> x;
some_type y = x; // the implicit operator is called
f(x);            // the implicit operator is called and the result goes to f.

所以你有时不得不使用.get(). 而不是总是使用->