使用自定义比较器的 std::set::insert 问题

Question

我写了一个小

struct

，用于对容器/解决方案中的项目之间的依赖关系进行排序（它实际上可以用于对任何东西进行排序，所使用的接口只是一个

std::string

）。

依赖项是从 json 对象定义和提供的（使用

boost::json

完成解析）。

依赖关系示例：

"container_dependency_tree": {
    "abc": ["def","hello","world"],
    "def": ["xyz","x","y"],
    "xyz": [],
},

标题：

#pragma once

#include <boost/json.hpp>
#include <map>
#include <string>
#include <vector>
#include <set>

namespace tmake {

    struct container_dependency_tree_t {
    private:

        std::map<std::string, std::vector<std::string>>
            m_flat;

        bool
            m_compare(const std::string& lhs, const std::string& rhs) const;//returns true if lhs depends on rhs

        std::set<std::string, decltype(&m_compare)>
            m_sorted = decltype(m_sorted)(&container_dependency_tree_t::m_compare);

    public:

        container_dependency_tree_t() {}

        container_dependency_tree_t(const boost::json::object& container_dependency_tree);

    public:

        const decltype(m_flat)&
            flat() const;

        const decltype(m_sorted)&
            sorted() const;
    };
}

实施：

#include <tmake/container_dependency_tree_t.h>

namespace tmake {

    container_dependency_tree_t::container_dependency_tree_t(const boost::json::object& container_dependency_tree) {
        for (const auto& kv : container_dependency_tree) {
            std::vector<std::string> dependencies;
            const boost::json::array& dd = kv.value().as_array();
            for (const auto& d : dd) {
                dependencies.push_back(d.as_string().c_str());
            }
            m_flat.emplace(kv.key(), dependencies);
        }

        for (const auto& f : m_flat) {
            m_sorted.insert(f.first);//***ISSUE HERE***
        }
    }

    bool container_dependency_tree_t::m_compare(const std::string& lhs, const std::string& rhs) const {
        auto find = m_flat.find(lhs);
        if (find == m_flat.end())
            return false;

        for (const auto& dependency : find->second) {
            if (rhs == dependency || m_compare(dependency, rhs)) {
                return true;
            }
        }

        return false;
    }

    const decltype(container_dependency_tree_t::m_flat)& container_dependency_tree_t::flat() const {
        return m_flat;
    }

    const decltype(container_dependency_tree_t::m_sorted)& container_dependency_tree_t::sorted() const {
        return m_sorted;
    }
}

问题在于指令

m_sorted.insert(f.first);

。

我遇到了一些我不明白的编译器的胡言乱语 - 错误位于 STL 实现文件中的某个位置（MSVC xutility(1372,19): error C2064: le terme ne recognizes pas à une fonction qui prend 2 argument)。

我做错了什么？

Answer 1

该错误来自于您尝试使用具有隐式第一个参数（即 this 指针）的类成员函数。由于您需要访问

m_flat

，因此需要包装要与要调用的函数一起使用的对象，以便

set

获得仅接受两个

const string&

参数的函数对象。你可以这样做

struct container_dependency_tree_t {
private:

    std::map<std::string, std::vector<std::string>>
        m_flat;

    bool 
        m_compare(const std::string& lhs, const std::string& rhs) const;//returns true if lhs depends on rhs

    std::set<std::string, std::function<bool(const std::string&, const std::string&)>>
        m_sorted = decltype(m_sorted)([this](const std::string& lhs, const std::string& rhs)
                   { 
                       return this->m_compare(lhs, rhs); 
                   });

public:

    container_dependency_tree_t() {}

    container_dependency_tree_t(const boost::json::object& container_dependency_tree);

public:

    const decltype(m_flat)&
        flat() const;

    const decltype(m_sorted)&
        sorted() const;
};