我有一个似乎无法解决的常量正确性问题。这是我的程序的结构:

class Node
{
    private:
        int            id;
        std::set<Node*> neighbours;
    public:
        Node();
        Node(int id_p);

        void set_id(const int& id_p);
        int  get_id() const;
        void add_neighbour(Node* neighbour);
        bool is_neighbour(Node* neighbour) const;

        friend bool operator <(const Node& lhs, const Node& rhs);
};

class Graph
{
    private:
        std::set<Node> node_list;
    public:
        Graph();

        void        add_node(int id);
        const Node* get_node_by_id(int id) const;
        bool        has_node(int id) const;
        void        check_add_node(int id);
        void        add_edge(int id_1, int id_2);
        bool        has_edge(int id_1, int id_2) const;
        void        check_add_edge(int id_1, int id_2);

        (...)
};

现在的问题是，如果我调用函数 Graph::get_node_by_id() ，我想返回一个指向给定节点的指针(类型 Node )。但这样做似乎是不可能的，因为 std::set将我的 Node 类型对象隐式转换为 const Node对象，我无法获取 non-const pointer来自const目的。

但是，我不能将其他所有设置为 const Node (这会解决问题)，因为我想调用 Node::add_neighbour()来自 Graph::add_edge() , 但每当我这样做时，我的编译器都会说我可能违反了 const node_list 中元素的 ness(需要有一个排序集)设置，即使我定义了 less operator<只关心 id .

我能做些什么来解决这个难题(不放弃排序集)？感谢您的回复!

有关错误的更多信息:

如果我使用非常量字段，则会在 Graph::get_node_by_id() 中出错:

for(Node& element : this->node_list) // Error: element should be const Node&
{
    if(element->get_id() == id)
    {
        return element;
    }
}
return nullptr;

如果我使用常量字段，则会在 Graph::add_edge() 中出错:

(...)
const Node* node_1 = this->get_node_by_id(id_1);
const Node* node_2 = this->get_node_by_id(id_2);
node_1->add_neighbour(node_2); // Error for disregarding constness
node_2->add_neighbour(node_1);

最佳答案

您的问题似乎是您对 Node 有两种不同的“值语义” .

一个是operator<暴露的不受 add_neighbour 影响.这是一个 set需要，以保持秩序，并通过制作 Node 来强制执行const .

另一个是由类API 公开的，其中set_id和 add_neighbour会改变值(value)。

保持排序set ，您不能允许节点的 ID 在集合中更改。但是您可以允许邻居改变。

所以我建议你制作 neighbours set mutable , 使 add_neighbour private和 const ，并制作Graph一个friend的 Node .

这就是mutable为您提供不属于类型“值”的数据成员。请注意，这意味着您表示持有 const Node* 的东西可以期待 is_neighbour 的结果在通话之间切换。

所以...

class Node
{
    private:
        // Trust Graph not to mess directly with these!
        int            id;
        mutable std::set<Node*> neighbours;

        friend class Graph;
        // For Graph's exclusive use
        void add_neighbour(Node* neighbour) const;


    public:
        Node();
        Node(int id_p);

        void set_id(const int& id_p); // Callable when not in Graph's set
        int  get_id() const;
        void add_neighbour(Node* neighbour);  // Callable when not in Graph's set
        bool is_neighbour(Node* neighbour) const;

        friend bool operator <(const Node& lhs, const Node& rhs);
};

class Graph
{
    private:
        std::set<Node> node_list;
    public:
        Graph();

        void        add_node(int id);
        const Node* get_node_by_id(int id) const;
        bool        has_node(int id) const;
        void        check_add_node(int id);
        void        add_edge(int id_1, int id_2);
        bool        has_edge(int id_1, int id_2) const;
        void        check_add_edge(int id_1, int id_2);

        (...)
};

现在您拥有的是 Node 的公共(public)、非常量突变器不在 Graph 中的实例的 set , 和一个额外的变元 Graph用于更改 Node 的邻居s 在其 set .

所以只有Graph可以做

const Node b;
b.add_neighbour(nullptr);

如果你真的不信任Graph , 你可以替换 private const add_neighbour带内部 class , 与 static add_neighbour(Node* node, Node* neighbour方法，因为内部 class能够隐式访问外部类的私有(private)数据。

class NeighbourHelper {
    friend class Graph;
    static void add(const Node* node, Node* neighbour) {
        node->add_neighbour(neighbour);
    }

现在只有Graph可以做

const Node b;
Node::NeighbourHelper::add(&b, nullptr);

在这两种情况下，以下内容适用于所有人:

Node a;
a.add_neighbour(nullptr);

在这一点上，您应该会闻到代码气味...问题是 public get_node_by_id图中的方法。您实际上可能想公开某种迭代器，而不是原始的 Node*。 ，并制作Node Graph 的私有(private)内部类。

或者甚至只是替换整个Node概念 std::map<int,std::set<int>> ...

但这取决于您的实际用例。

关于c++ - 如何纠正这个常量？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/35074619/