背景

Question

（这可能是XY Problem，所以在实际提问之前，我会提供一些背景信息。）

背景

我目前有一个函数（不是模板），可以计算不同的哈希类型（CRC32，MD5，SHA1等）。数据来自提供程序，该提供程序一次只能提供指向数据块的指针。该函数迭代地计算数据块上的哈希。

前进到下一块是非常昂贵的操作（涉及解压缩），并且只能前进。同样，该体系结构必须保持零复制。结果，必须在迭代相同的数据块时立即计算所有选定的哈希。哈希类型选择通过bool参数完成：

std::tuple<uint32_t, QByteArray, QByteArray, QByteArray>
computeHashes(DataProvider& data, bool do_crc, bool do_md5, bool do_sha1,
              bool do_sha256);

如果其中一个标志为false，则调用方将忽略相应的空元组元素。

实际问题

我对上述API感到非常不满意。因此，我决定编写一个外观更简洁的功能模板。返回值中没有布尔开关，也没有伪元组元素：

auto [crc, sha256] = computeHashes<Hash::CRC32, Hash::MD5>(data_provider);

除了需要实际返回结果的最后一步之外，我的代码大部分都能正常工作。这是从实际代码中删减的，并且仅使用两个哈希函数，以使示例尽可能简短：

enum class Hash { CRC32, MD5 };

template <HashType> struct Hasher
{};

template<> struct Hasher<HashType::CRC32>
{
    void addData(const char* data, int len);
    uint32_t result() const;
};

template<> struct Hasher<HashType::MD5>
{
    void addData(const char* data, int len);
    QByteArray result() const;
};

template <HashType... hash_types>
auto computeHashes(DataProvider& provider)
{
    std::tuple<Hasher<hash_types>...> hashers;

    while (provider.hasMoreChunks()) {
        auto [chunk, len] = provider.nextChunk();
        std::apply([chunk, len](auto&... hasher)
                       { (..., hasher.addData(chunk, len); },
                   hashers);
    }
    return std::make_tuple( ??? );
}

我被困在最后一步：如何返回每个结果？硬编码的退货应如下所示：

return std::make_tuple(res, std::get<0>(hashers).result(),
                       std::get<1>(hashers).result());

这当然不合适。我该怎么做？

Answer 1

由于std::apply通过decltype(auto)转发返回的值，因此您可以仅使用std::apply构造一个元组并返回它。您可以将转换合并为一个调用。

template <HashType... hash_types>
static auto computeHashes(DataProvider& provider)
{
    return std::apply(
        [&provider](auto&&... hashers) { 
            while (provider.hasMoreChunks()) 
            {
                auto [chunk, len] = provider.nextChunk();
                (..., hashers.addData(chunk, len));
            }

            return std::make_tuple(std::move(hashers.result())...);
        },
        std::tuple<Hasher<hash_types>...>{}
    );
}

根据另一个元组中对象的成员函数返回的值构造一个元组

背景

实际问题

1 个答案: