为什么我们不能将带有自定义比较lambda的`std :: multiset`用作`std :: map`的值？

时间：2019-06-01 22:28:40

标签： c++ lambda c++17 multiset custom-compare

这是询问的后续问题 Custom comparator for set without overloading operator(), std::less, std::greater

我试图通过以下方式解决。

基本

可以向类的成员std::multiset提供自定义比较lambda函数（自起），如下所示：

#include <iostream>
#include <set>

const auto compare = [](int lhs, int rhs) noexcept { return lhs > rhs; };
struct Test
{
    std::multiset<int, decltype(compare)> _set{compare};
    Test() = default;
};

很简单。

我的处境

Test类的成员是

std::map<std::string, std::multiset<int, /* custom compare */>> scripts{};

我尝试通过自定义

使用std::multiset
  • functor Compare（情况-1）
  • std::greater<>（案例-2）
  • lambda函数（案例-3）

前两个选项均成功。但是，lambda作为自定义比较功能的情况却无法正常工作。这是MCVC：https://godbolt.org/z/mSHi1p 

#include <iostream>
#include <functional>
#include <string>
#include <map>
#include <set>

const auto compare = [](int lhs, int rhs) noexcept { return lhs > rhs; };
class Test
{
private:
    struct Compare
    {
        bool operator()(const int lhs, const int rhs) const noexcept { return lhs > rhs; }
    };

private:
    // std::multiset<int, Compare> dummy;                      // works fine
    // std::multiset<int, std::greater<>> dummy;               // works fine
    // std::multiset<int, decltype(compare)> dummy{ compare }; // does not works
    using CustomMultiList = decltype(dummy);

public: 
    std::map<std::string, CustomMultiList> scripts{};
};

int main()
{
    Test t{};    
    t.scripts["Linux"].insert(5);
    t.scripts["Linux"].insert(8);
    t.scripts["Linux"].insert(0);

    for (auto a : t.scripts["Linux"]) {
        std::cout << a << '\n';
    }
}

错误消息：

error C2280 : '<lambda_778ad726092eb2ad4bce2e3abb93017f>::<lambda_778ad726092eb2ad4bce2e3abb93017f>(void)' : attempting to reference a deleted function
note: see declaration of '<lambda_778ad726092eb2ad4bce2e3abb93017f>::<lambda_778ad726092eb2ad4bce2e3abb93017f>'
note: '<lambda_778ad726092eb2ad4bce2e3abb93017f>::<lambda_778ad726092eb2ad4bce2e3abb93017f>(void)' : function was explicitly deleted
note: while compiling class template member function 'std::multiset<int,const <lambda_778ad726092eb2ad4bce2e3abb93017f>,std::allocator<int>>::multiset(void)'
note: see reference to function template instantiation 'std::multiset<int,const <lambda_778ad726092eb2ad4bce2e3abb93017f>,std::allocator<int>>::multiset(void)' being compiled
note: see reference to class template instantiation 'std::multiset<int,const <lambda_778ad726092eb2ad4bce2e3abb93017f>,std::allocator<int>>' being compiled

这听起来像是我尝试默认构造传递的lambda，which is not possible直到。

如果该案发生在哪里？ 是否可以在到的范围内使用lambda比较函数来解决此问题？

2 个答案:

答案 0 :(得分：8)

  

听起来我尝试默认构造传递的lambda，   在之前是不可能的。如果是这样的话发生在哪里？

是。正是由于在行上std::map::operator[]的调用而在这里发生了

t.scripts["Linux"].insert(5);
//       ^^^^^^^^^

让我们详细研究一下。上面的调用将导致以下重载的调用，因为密钥是由std::string构造的临时const char*。

T& operator[]( Key&& key );

自C++17 this is equivalent to起：

return this->try_emplace(
    std::move(key)).first  ->  second;
//               key_type    mapped_type
//               ^^^^^^^^    ^^^^^^^^^^^
//                  |           |
//                  |           |
//             (std::string)  (std::multiset<int, decltype(compare)>)
//                  |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
//                  |           |                               (default-construction meaning)
//                  |       default-construction -->   std::multiset<int, decltype(compare)>{}
//               move-construction                                                          ^^

其中 key_type （即从std::string临时构建的const char*）应该为 move constructible ， 发生的很好。

mapped_type （即std::multiset<int, decltype(compare)>）应首先 default construct 进行编辑，并且需要比较lambda也应默认构造。来自cppreference.com：

  

ClosureType :: ClosureType（） 

ClosureType() = delete;   (until C++14)
ClosureType() = default;  (since C++20)(only if no captures are specified)
     

关闭类型不是DefaultConstructible 。闭合类型有一个   删除（直到C ++ 14）没有（自C ++ 14起）默认构造函数。 (until C++20)

     
     

如果未指定捕获，则关闭类型具有默认默认值   构造函数。否则，它没有默认的构造函数（其中包括   存在捕获默认值的情况，即使实际上没有   捕获任何东西）。 (since C++20)

这意味着，lambda闭包类型的默认构造在C ++ 17中不可用（这是编译器错误所抱怨的）。

另一方面，在compare lambda中没有指定捕获（即无状态lambda），因此支持C ++的编译器可以明确将其默认设置20标准。

  

是否可以在内部使用Lambda比较功能解决此问题   到的范围？

不是通过使用std::map::operator[] （由于上述原因），而是是，就像@JohnZwinck的回答中提到的那样。我想解释一下它是如何工作的。

std::multiset的构造函数之一 1 提供了传递比较器对象的可能性。

template< class InputIt >
multiset( InputIt first, InputIt last,
          const Compare& comp = Compare(),
//        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ 
          const Allocator& alloc = Allocator() );

同一时间，lambda闭包类型的副本构造函数和move构造函数为defaulted since C++14。这意味着，如果我们有可能将lambda作为第一个参数 2 （通过复制或移动它）来提供，则它将是 Basic < / strong>案例，问题中显示的内容。

std::multiset<int, decltype(compare)> dummy{ compare };            // copying
std::multiset<int, decltype(compare)> dummy{ std::move(compare) }; // moving

幸运的是，C ++ 17引入了成员函数std::map::try_emplace 

template <class... Args>
pair<iterator, bool> try_emplace(key_type&& k, Args&&... args);

可以将lambda传递给std::multiset的上述构造函数 1 作为第一个参数 2 。如果将其扭曲到Test类的成员函数中，则可以将元素插入到CustomMultiList映射的scripts（即值）中。

解决方案看起来像（与链接的帖子相同，因为我在问了这个问题之后才写了这个答案！）

（See Live）

#include <iostream>
#include <string>
#include <map>
#include <set>

// provide a lambda compare
const auto compare = [](int lhs, int rhs) noexcept { return lhs > rhs; };

class Test
{
private:
    // make a std::multi set with custom compare function  
    std::multiset<int, decltype(compare)> dummy{ compare };
    using CustomMultiList = decltype(dummy); // use the type for values of the map 
public:
    std::map<std::string, CustomMultiList> scripts{};
    // warper method to insert the `std::multilist` entries to the corresponding keys
    void emplace(const std::string& key, const int listEntry)
    {
        scripts.try_emplace(key, compare).first->second.emplace(listEntry);
    }
    // getter function for custom `std::multilist`
    const CustomMultiList& getValueOf(const std::string& key) const noexcept
    {
        static CustomMultiList defaultEmptyList{ compare };
        const auto iter = scripts.find(key);
        return iter != scripts.cend() ? iter->second : defaultEmptyList;
    }
};

int main()
{
    Test t{};
    // 1: insert using using wrapper emplace method
    t.emplace(std::string{ "Linux" }, 5);
    t.emplace(std::string{ "Linux" }, 8);
    t.emplace(std::string{ "Linux" }, 0);


    for (const auto a : t.getValueOf(std::string{ "Linux" }))
    {
        std::cout << a << '\n';
    }
    // 2: insert the `CustomMultiList` directly using `std::map::emplace`
    std::multiset<int, decltype(compare)> valueSet{ compare };
    valueSet.insert(1);
    valueSet.insert(8);
    valueSet.insert(5);
    t.scripts.emplace(std::string{ "key2" }, valueSet);

    // 3: since C++20 : use with std::map::operator[]
    // latest version of GCC has already included this change
    //t.scripts["Linux"].insert(5);
    //t.scripts["Linux"].insert(8);
    //t.scripts["Linux"].insert(0);

    return 0;
}

答案 1 :(得分：1)

要在一行中完成此操作，您需要这样的内容：

t.scripts.try_emplace("Linux", compare).first->second.insert(5);

这是因为必须将compare传递给multiset的构造函数。否则，将没有比较对象，并且无法构造multiset。

演示：https://godbolt.org/z/rVb3-D

相关问题
最新问题