您需要简化代码并使用std::visit。下面是一个使用std::variant调度响应的简单版本：https://godbolt.org/z/jTYj8o13e

#include <variant>
#include <string>
#include <vector>
#include <iostream>

struct request_a {};
struct request_b{};

struct response_a{
    std::string value;
};
struct response_b{
    int value;
};

response_a respond(request_a) {
    std::cout << "responding to request_a\n";

    return {"oceanic"};
} 

response_b respond(request_b) {
    std::cout << "responding to request_b\n";

    return {815};
} 

int main() {

    std::vector<std::variant<request_a, request_b>> requests{request_a(), request_b()};

    for (const auto &req : requests)
    {
        std::visit([](const auto &req){
            std::cout << respond(req).value << '\n';
        }, req);
    }

    return 0;
}

输出：

responding to request_a
oceanic
responding to request_b
815

好吧，我没有找到在getResponse或其他函数中访问对象本身的方法（std：：get〈〉（variant）），但我意识到，实际上我不需要访问它。
我通过将对象进一步传播为std：：（更新GetVariantTypeInfo）使其工作，在那里我可以将其转换为模板返回类型，这就是我在返回响应时实际需要的。

// Helper function that calls GetVariantTypeInfoPointer for each type in a parameter pack
template <typename... Ts>
std::pair<const std::type_info*, std::any> GetVariantTypeInfo(std::variant<Ts...>& variant)
{
    // Call GetVariantTypeInfo for each type in the parameter pack using fold expression
    const std::initializer_list<std::pair<const std::type_info*, std::any>> typeInfos = { GetVariantTypeInfo<Ts, Ts...>(variant)... };
    for (const auto& typeInfo : typeInfos)
    {
        if (typeInfo.first != nullptr)
        {
            return typeInfo;
        }
    }

    return std::make_pair(nullptr, std::any());
}

template <typename T>
    std::enable_if_t<response_is_in_pack<T>, std::optional<std::shared_ptr<T>>>
        getResponse(ChannelIndex channel, const std::type_info& requestType) {

        //some code ...

        const auto responseTypeInfo =
            GetVariantTypeInfo<std::shared_ptr<typename Pairs::second_type>...>
            (m_journal[channel].responseContainer);

        return std::any_cast<std::shared_ptr<T>>(responseTypeInfo.second);
    }

我很好奇如何用std：：visit实现它，所以很高兴看到这个例子。谢谢大家的帮助。
使用的简化示例：

struct RequestA {
    std::string data;
};

struct ResponseA {
    int code;
};

struct RequestB {
    int data;
};

struct ResponseB {
    double value;
};

int main(int argc, char* argv[])
{
    constexpr std::size_t channelsNum = 6;
    RequestJournal<channelsNum, std::pair<RequestA, ResponseA>, std::pair<RequestB, ResponseB>> requestJournal{ 1000000 };

    // Start the first thread which generates requests
    std::thread requestThread([&requestJournal, channelsNum]() {
        for (int i = 0; i < channelsNum; i++) {
            if (i % 2 == 0) {
                auto request = std::make_shared<RequestA>(RequestA{ "RequestA data #" + std::to_string(i) });
                requestJournal.addRequest(i, request);
            }
            else {
                auto request = std::make_shared<RequestB>(RequestB{ i });
                requestJournal.addRequest(i, request);
            }
            std::this_thread::sleep_for(std::chrono::milliseconds(10)); // sleep for 10 milliseconds
        }

        while (requestJournal.getPendingRequestsNum(typeid(RequestA)) != 0) {
            // Check the responses
            for (int i = 0; i < channelsNum; i++) {

                auto responseA = requestJournal.getResponse<ResponseA>(i, typeid(RequestA));
                if (responseA.has_value() == true) {
                    std::cout << "ResponseA received: " << responseA->get()->code << std::endl;
                }
            }
        }

        while (requestJournal.getPendingRequestsNum(typeid(RequestB)) != 0) {
            // Check the responses
            for (int i = 0; i < channelsNum; i++) {

                auto responseB = requestJournal.getResponse<ResponseB>(i, typeid(RequestB));
                if (responseB.has_value()) {
                    std::cout << "ResponseB received: " << responseB->get()->value << std::endl;
                }
            }
        }
        });

    // Start the second thread which sets responses
    std::thread responseThread([&requestJournal, channelsNum]() {
        for (int i = 0; i < channelsNum; i++) {
            std::this_thread::sleep_for(std::chrono::milliseconds(20)); // sleep for 20 milliseconds
            if (i % 2 == 0) {
                auto response = std::make_shared<ResponseA>(ResponseA{ 200 });
                requestJournal.setResponse(i, response);
            }
            else {
                auto response = std::make_shared<ResponseB>(ResponseB{ 3.14 });
                requestJournal.setResponse(i, response);
            }
        }
        });

    // Wait for the threads to finish
    requestThread.join();
    responseThread.join();
}