c++ - C++错误C2280-尝试引用已删除的函数-在原始类型上

Question

我正在实现自己的两个无序映射，一个带有一个键，该键是带有3个参数的元组，另一个是带有2个参数的元组。以下是我的代码:

#pragma once

#include <boost/functional/hash.hpp>

#include <unordered_map>
#include <tuple>

namespace Valk::ExchangeGateway::TupleMap
{
    using boost::hash_value;
    using boost::hash_combine;
    template <typename T, typename U>
    auto hashTuple = [](const std::tuple<T, U>& singleTuple) -> size_t
    { 
        size_t seed{}; 
        hash_combine(seed, hash_value(std::get<0>(singleTuple)));
        hash_combine(seed, hash_value(std::get<1>(singleTuple)));
        return seed;
    };
    template <typename T, typename U>
    auto equalTuple = [](const std::tuple<T, U>& firstTuple, const std::tuple<T, U>& secondTuple) -> bool
    {
        return std::get<0>(firstTuple) == std::get<0>(secondTuple)
            && std::get<1>(firstTuple) == std::get<1>(secondTuple);
    };
    template <typename T, typename U, typename D>
    auto hashTripleTuple = [](const std::tuple<T, U, D>& singleTuple) -> size_t
    {
        size_t seed{};
        hash_combine(seed, hash_value(std::get<0>(singleTuple)));
        hash_combine(seed, hash_value(std::get<1>(singleTuple)));
        hash_combine(seed, hash_value(std::get<2>(singleTuple)));
        return seed;
    };
    template <typename T, typename U, typename D>
    auto equalTripleTuple = 
            [](const std::tuple<T, U, D>& firstTuple, const std::tuple<T, U, D>& secondTuple) -> bool
    {
        return std::get<0>(firstTuple) == std::get<0>(secondTuple)
            && std::get<1>(firstTuple) == std::get<1>(secondTuple)
            && std::get<2>(firstTuple) == std::get<2>(secondTuple);
    };

    using InstrumentFrequency = int;
    using TotalDelta = double;

    using FutureTupleUnorderedMap = std::unordered_map<std::tuple<TotalDelta, Instrument::InstrumentID, Platform::Price>,
        InstrumentFrequency, decltype(hashTripleTuple<TotalDelta, Instrument::InstrumentID, Platform::Price>),
        decltype(equalTripleTuple<TotalDelta, Instrument::InstrumentID, Platform::Price>)>;

    using OptionTupleUnorderedMap = std::unordered_map<std::tuple<Platform::Quantity, Instrument::InstrumentID>,
        InstrumentFrequency, decltype(hashTuple<Platform::Quantity, Instrument::InstrumentID>),
        decltype(equalTuple<Platform::Quantity, Instrument::InstrumentID>)>;
}

您看到的所有typedef，例如 Platform::Quantity和 Platform::Price都是基本类型的typedef，例如 long long或 int。

由于某种原因，我遇到以下错误(屏幕快照比在此处复制和粘贴容易)，但我不确定为什么。这里没有一个类，其副本构造函数已删除或未生成。



谢谢你的帮助。

Answer 1

Lambda不是默认可构造的。因此，您需要传递哈希/等于运算符。另外，您可以派生lambda的命名类型并添加默认的可构造性:

最简单的方法是为双元组/三元组组合哈希分别相等的操作:

struct HashTuple {
    template <typename T, typename U>
    auto operator()(const std::tuple<T, U>& singleTuple) const -> size_t
    { 
        size_t seed{}; 
        hash_combine(seed, hash_value(std::get<0>(singleTuple)));
        hash_combine(seed, hash_value(std::get<1>(singleTuple)));
        return seed;
    }

    template <typename T, typename U, typename D>
    auto operator()(const std::tuple<T, U, D>& singleTuple) const -> size_t
    {
        size_t seed{};
        hash_combine(seed, hash_value(std::get<0>(singleTuple)));
        hash_combine(seed, hash_value(std::get<1>(singleTuple)));
        hash_combine(seed, hash_value(std::get<2>(singleTuple)));
        return seed;
    }
};

struct EqualTuple {
    template <typename... T>
    auto operator()(const std::tuple<T...>& firstTuple, const std::tuple<T...>& secondTuple) const -> bool {
        return firstTuple == secondTuple;
    }
};

Note this uses the equivalent std::tuple::operator== implementation

现在，您可以简化类型:

std::unordered_map<std::tuple<double, int, double>, int, HashTuple, EqualTuple>
std::unordered_map<std::tuple<unsigned int, int>, int, HashTuple, EqualTuple>

我用一个简单的助手总结了一下:

template <typename... Key> using FrequencyMap = 
    std::unordered_map<std::tuple<Key...>, InstrumentFrequency, HashTuple, EqualTuple>;

using FutureTupleUnorderedMap = FrequencyMap<TotalDelta, Instrument::InstrumentID, Platform::Price>;
using OptionTupleUnorderedMap = FrequencyMap<Platform::Quantity, Instrument::InstrumentID>;

现在，我们有一个可以正常运行的演示:

Live On Coliru

#include <boost/functional/hash.hpp>

#include <tuple>
#include <unordered_map>

struct Instrument {
    using InstrumentID = int;
};
struct Platform {
    using Quantity = unsigned;
    using Price = double;
};

namespace Valk::ExchangeGateway::TupleMap {
    struct HashTuple {
        template <typename T, typename U>
        auto operator()(const std::tuple<T, U>& singleTuple) const -> size_t
        { 
            using boost::hash_value;
            using boost::hash_combine;
            size_t seed{}; 
            hash_combine(seed, hash_value(std::get<0>(singleTuple)));
            hash_combine(seed, hash_value(std::get<1>(singleTuple)));
            return seed;
        }

        template <typename T, typename U, typename D>
        auto operator()(const std::tuple<T, U, D>& singleTuple) const -> size_t
        {
            using boost::hash_value;
            using boost::hash_combine;
            size_t seed{};
            hash_combine(seed, hash_value(std::get<0>(singleTuple)));
            hash_combine(seed, hash_value(std::get<1>(singleTuple)));
            hash_combine(seed, hash_value(std::get<2>(singleTuple)));
            return seed;
        }
    };

    struct EqualTuple {
        template <typename... T>
        auto operator()(const std::tuple<T...>& firstTuple, const std::tuple<T...>& secondTuple) const -> bool {
            return firstTuple == secondTuple;
        }
    };

    using InstrumentFrequency = int;
    using TotalDelta = double;


    template <typename... Key> using FrequencyMap = 
        std::unordered_map<std::tuple<Key...>, InstrumentFrequency, HashTuple, EqualTuple>;

    using FutureTupleUnorderedMap = FrequencyMap<TotalDelta, Instrument::InstrumentID, Platform::Price>;
    using OptionTupleUnorderedMap = FrequencyMap<Platform::Quantity, Instrument::InstrumentID>;
}

#include <boost/core/demangle.hpp>
#include <iostream>
int main() {
    {
        Valk::ExchangeGateway::TupleMap::FutureTupleUnorderedMap ftum;
        std::cout << boost::core::demangle(typeid(ftum).name()) << "\n";
    }
    {
        Valk::ExchangeGateway::TupleMap::OptionTupleUnorderedMap otum;
        std::cout << boost::core::demangle(typeid(otum).name()) << "\n";
    }
}

打印您在上面看到的类型名称。