C++ C++；模板化类对象的向量

我不知道是否有可能实现我正在尝试的目标，但也许有人能指引我走向正确的方向。旁注：这是一个嵌入式系统

我有一个SPI通信，它返回表示一组寄存器的

std:：vector

。这是在一个单独的异步线程中完成的。 为了处理这个问题，我在每个

read

调用中创建一个包含

std:：promise

（以及一些其他信息）的对象，并直接返回它的

未来

，以便调用方可以等待结果

一旦SPI传输完成，我将相应地设置承诺的值。到目前为止还不错

现在我想做的是不总是返回类型为

std:：vector

的future，而是对向量进行一些预处理，然后返回

int

或

double

甚至是

结构。
我想我可以通过将匿名函数交给
read
函数并在对象中存储引用来实现这一点。然后在分配承诺之前调用此函数

我现在的问题是，这个函数的返回类型直接影响我的承诺的返回类型，并且存储它们的对象不再总是相同的。所以我想我只是做了个模板

template <class ret_type>
class obj{
    public:
    std::promise<ret_type> prms;
    ret_type (*map_function)(std::vector<int>);
    ...
};

模板
obj类{
公众：
std：：promise-prms；
ret_类型（*映射函数）（标准：：向量）；
...
};

但现在我必须解决的问题是，包含这些对象的向量（SPI队列）的类型是
std:：vector
，无法容纳不同类型的对象

有没有合适的方法来解决这个问题

编辑：
我会用一种类似于

for(auto &element : vector){
    std::vector<int> answer_from_spi = spi_read();
    element.prms.set_value(element.map_function(answer_from_spi));
}

for（自动&元素：矢量）{
std：：向量回答来自spi=spi_read（）；
element.prms.set_值（element.map_函数（answer_from_spi））；
}
注意：由于我没有足够的声誉发表评论，我正在写一个答案

如果可以使用C++17，那么可能可以使用std:：any。

在C++17之前，您可以创建多态类（定义基类、要返回和存储的不同类型的派生类），并将指向它们的指针存储在向量中。大概是这样的：

vec
vec.push_-back（派生1）
vec.push_-back（派生2）

请参阅以下答案：

注意：由于我没有足够的声誉发表评论，我正在写一个答案

如果可以使用C++17，那么可能可以使用std:：any。

在C++17之前，您可以创建多态类（定义基类、要返回和存储的不同类型的派生类），并将指向它们的指针存储在向量中。大概是这样的：

vec
vec.push_-back（派生1）
vec.push_-back（派生2）

请参阅以下答案：

bog标准解决方案包括将整个类型变化部件移动到虚拟功能中。在向量中存储指向基类的（智能）指针，并在派生类中实现虚函数

class obj {
  public:
    virtual void set_promise () = 0;
};

template <class ret_type>
class obj_impl : public obj {
    std::promise<ret_type> prms;
    ret_type (*map_function)(const std::vector&<int>);
    void set_promise () override {
        std::vector<int> answer_from_spi = spi_read();
        prms.set_value(map_function(answer_from_spi));
    }
};

std::vector<std::unique_ptr<obj>> objects;
for(auto &element : objects)
    element->set_promise();

类obj{
公众：
虚空集_promise（）=0；
};
模板
类别obj_impl：公共obj{
std：：promise-prms；
ret_类型（*映射函数）（常数std:：vector&）；
void set_promise（）覆盖{
std：：向量回答来自spi=spi_read（）；
prms.set_值（map_函数（应答_来自_spi））；
}
};
向量对象；
用于（自动元素：对象（&E）
元素->设置承诺（）；
bog标准解决方案包括将整个类型变化部件移动到虚拟功能中。在向量中存储指向基类的（智能）指针，并在派生类中实现虚函数

class obj {
  public:
    virtual void set_promise () = 0;
};

template <class ret_type>
class obj_impl : public obj {
    std::promise<ret_type> prms;
    ret_type (*map_function)(const std::vector&<int>);
    void set_promise () override {
        std::vector<int> answer_from_spi = spi_read();
        prms.set_value(map_function(answer_from_spi));
    }
};

std::vector<std::unique_ptr<obj>> objects;
for(auto &element : objects)
    element->set_promise();

类obj{
公众：
虚空集_promise（）=0；
};
模板
类别obj_impl：公共obj{
std：：promise-prms；
ret_类型（*映射函数）（常数std:：vector&）；
void set_promise（）覆盖{
std：：向量回答来自spi=spi_read（）；
prms.set_值（map_函数（应答_来自_spi））；
}
};
向量对象；
用于（自动元素：对象（&E）
元素->设置承诺（）；
也许您只需要使用
std:：variant
？
std:：vector
？如果有一个没有std:：variant的解决方案，那就太好了，因为否则我必须指定所有可能的返回类型，返回类型可能非常多。也许我错了，但是如果
ret\u type
是我的类的类型说明符，那么类型为
std:：vector
的向量应该是什么样子呢？那么假设您可以在假设的
std:：vector
中存储不同类型的对象（实际上，
obj
不是一种类型，所以这样的向量不可能存在，但让我们暂时忘掉它）。您将如何使用此向量？请显示（伪）代码。您已将
obj
定义为模板，因此
obj
不是一个类型，并且
vector
不存在。如果您将
obj
定义为一个类型，那么
obj:：prms
是什么类型？可能您只需要使用
std:：variant
？
std:：vector
？如果有一个没有std:：variant的解决方案这太好了，因为否则我必须指定所有可能的返回类型，返回类型可能很多。也许我错了，但是如果
ret_type
是我的类的类型说明符，那么类型为
std:：vector
的向量应该是什么样子呢？所以假设您可以在假设的
std:：vector
中存储不同类型的对象（实际上，
obj
不是一种类型，所以这样的向量不可能存在，但让我们暂时忘掉它）。您将如何使用此向量？请显示（伪）代码。您已将
obj
定义为模板，因此
obj
不是一个类型，
vector
不存在。如果您将
obj
定义为一个类型，那么
obj:：prms
是什么类型？我将如何设置
map\u函数
？它告诉我
obj
没有s