在函数指针输入输出中运用多态遇编译错误，求解决方案

编译错误的核心原因有两个：

1. 容器无协变性：std::vector<intInput> 和 std::vector<input> 是完全独立的类型，不存在继承关系，因此无法隐式转换。即使intInput继承自input，容器本身不支持这种协变转换。
2. 函数指针类型不匹配+对象切片：doubling的签名是intResult(intInput)，但pipeline要求的是result(*)(input)，类型完全不兼容。而且就算强行转换，值传递input参数会触发对象切片——intInput对象传入后会被截断为input，丢失x成员，导致逻辑错误。

方案1：使用模板实现通用映射函数（更简洁灵活） #

既然你的需求是实现一个通用的"pipeline"映射函数，模板是更合适的选择，它天然支持任意输入输出类型，无需依赖多态基类：

#include <iostream>
#include <vector>
#include <functional>

template<typename InputType, typename OutputType>
std::vector<OutputType> pipeline(const std::vector<InputType>& input_vec, std::function<OutputType(const InputType&)> func) {
    std::vector<OutputType> res;
    res.reserve(input_vec.size()); // 预分配空间提升性能
    for (const auto& elem : input_vec) {
        res.push_back(func(elem));
    }
    return res;
}

// 示例处理函数
int doubling(int x) {
    return 2 * x;
}

void print_int(int x) {
    std::cout << x << " ";
}

int main() {
    std::vector<int> v{1,2,3,4};
    auto doubled = pipeline<int, int>(v, doubling);
    
    // 打印结果
    pipeline<int, void>(doubled, print_int);
    std::cout << std::endl;
    
    return 0;
}

方案2：基于多态+智能指针实现（支持混合类型容器） #

如果需要处理多种不同输入类型的混合容器，可通过指针/智能指针避免对象切片，结合多态实现：

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

struct Input {
    virtual ~Input() = default; // 必须定义虚析构函数，确保派生类对象正确销毁
};

struct IntInput : public Input {
    IntInput(int x) : x(x) {}
    int x;
};

struct Result {
    virtual ~Result() = default;
};

struct IntResult : public Result {
    IntResult(int y) : y(y) {}
    int y;
};

// 使用智能指针容器，避免对象切片
std::vector<std::unique_ptr<Result>> pipeline(const std::vector<std::unique_ptr<Input>>& input_vec, 
                                              std::function<std::unique_ptr<Result>(const Input&)> func) {
    std::vector<std::unique_ptr<Result>> res;
    res.reserve(input_vec.size());
    for (const auto& elem : input_vec) {
        // 动态转换确保类型安全
        if (const auto* int_in = dynamic_cast<const IntInput*>(elem.get())) {
            res.push_back(func(*int_in));
        }
    }
    return res;
}

std::unique_ptr<Result> doubling(const Input& in) {
    const auto& int_in = dynamic_cast<const IntInput&>(in);
    return std::make_unique<IntResult>(2 * int_in.x);
}

void print_result(const Result& res) {
    const auto& int_res = dynamic_cast<const IntResult&>(res);
    std::cout << int_res.y << " ";
}

int main() {
    std::vector<std::unique_ptr<Input>> v;
    v.emplace_back(std::make_unique<IntInput>(1));
    v.emplace_back(std::make_unique<IntInput>(2));
    v.emplace_back(std::make_unique<IntInput>(3));
    v.emplace_back(std::make_unique<IntInput>(4));
    
    auto results = pipeline(v, doubling);
    
    // 打印结果
    for (const auto& res : results) {
        print_result(*res);
    }
    std::cout << std::endl;
    
    return 0;
}

关键要点说明 #

• 避免对象切片：当需要多态时，必须使用指针或引用传递/存储对象，不能直接用值类型，否则派生类的额外成员会被截断。
• 模板 vs 多态：模板适合类型确定的通用映射场景，代码更简洁高效；多态适合需要处理混合类型容器的场景，灵活性更高但有一定运行时开销。
• 虚析构函数：多态基类必须定义虚析构函数，否则销毁派生类对象时会导致未定义行为。

内容的提问来源于stack exchange，提问作者roi_saumon