在 const 方法中使用引用

发布于 2024-10-19 08:47:56 字数 504 浏览 2 评论 0原文

假设我有一个这样的类:

class LinkedList
{
    struct Node
    {
        int StoredValue;
        // ...
    };

    Node& GetNodeReference(std::size_t Index)
    {
        // ...

        return NodeReference;
    }

    public:

    int Get(std::size_t Index) const
    {
        return GetNodeReference(Index).StoredValue;
    }
};

这不会编译,因为 const 方法 Get 使用 GetNodeReference,它不能是 const 因为它返回一个引用。

我该如何解决这个问题?

Let's say I have a class like this:

class LinkedList
{
    struct Node
    {
        int StoredValue;
        // ...
    };

    Node& GetNodeReference(std::size_t Index)
    {
        // ...

        return NodeReference;
    }

    public:

    int Get(std::size_t Index) const
    {
        return GetNodeReference(Index).StoredValue;
    }
};

This won't compile because the const method Get uses GetNodeReference, which cannot be const because it returns a reference.

How can I work around this?

如果你对这篇内容有疑问,欢迎到本站社区发帖提问 参与讨论,获取更多帮助,或者扫码二维码加入 Web 技术交流群。

扫码二维码加入Web技术交流群

发布评论

需要 登录 才能够评论, 你可以免费 注册 一个本站的账号。

评论(4

荒芜了季节 2024-10-26 08:47:56

我不确定您想要实现什么,但您可以提供 GetNodeReference 的两个重载:

Node& GetNodeReference(std::size_t Index)
{
    // ...

    return NodeReference;
}

const Node& GetNodeReference(std::size_t Index) const
{
    // ...

    return NodeReference;
}

请注意,第二个重载有两个 const 修饰符,一个在开头返回类型所在行的第一个,以及隐式传递的 *this 对象的行尾的一个。

为了避免代码重复,您可以在 const 重载的基础上实现非常量重载:

const Node& GetNodeReference(std::size_t Index) const
{
    // ...

    return NodeReference;
}

Node& GetNodeReference(std::size_t Index)
{
    return const_cast<Node&>(static_cast<const LinkedList&>(*this).getNodeReference(Index));
}

该技术在 Scott Meyers 的 Effective C++ 的第 3 条中进行了讨论。

I'm not sure what you're trying to achieve, but you could provide two overloads of GetNodeReference:

Node& GetNodeReference(std::size_t Index)
{
    // ...

    return NodeReference;
}

const Node& GetNodeReference(std::size_t Index) const
{
    // ...

    return NodeReference;
}

Note that the second overload has two const modifers, one at the beginning of the line for the return type and one at the end of the line for the implicitly passed *this object.

To avoid code repetition, you can implement the non-const overload based on the const overload:

const Node& GetNodeReference(std::size_t Index) const
{
    // ...

    return NodeReference;
}

Node& GetNodeReference(std::size_t Index)
{
    return const_cast<Node&>(static_cast<const LinkedList&>(*this).getNodeReference(Index));
}

This technique is discussed in Item 3 of Effective C++ by Scott Meyers.

十年不长 2024-10-26 08:47:56

根本不要为列表实现索引 Get 函数。对于新开发人员来说,在循环中使用它,将线性交互转换为多项式迭代,这太容易了。

如果您需要这样的功能,请创建一个自由函数,将列表的内置迭代器与 std::advance 结合使用来获取您想要的节点。

如果您绝对需要成员函数,那么正常的方法是@FredOverflow 建议的方法并使用重载(引用他的代码):

const Node& GetNodeReference(std::size_t Index) const
{
    // ...

    return NodeReference;
}

Node& GetNodeReference(std::size_t Index)
{
    return const_cast<Node&>(static_cast<const LinkedList&>(*this).getNodeReference(Index));
}

Don't implement an indexed Get function for lists at all. It will be WAY too easy for a new developer to come in and use it in a loop, turning a linear interation into a polynomial iteration.

If you need such a capability, make a free-function that uses the builtin iterators of the list in conjunction with say std::advance to get the node you want.

If you absolutely need the member function, then the normal approach is the one suggested by @FredOverflow and use overloads (quote his code):

const Node& GetNodeReference(std::size_t Index) const
{
    // ...

    return NodeReference;
}

Node& GetNodeReference(std::size_t Index)
{
    return const_cast<Node&>(static_cast<const LinkedList&>(*this).getNodeReference(Index));
}
偏爱自由 2024-10-26 08:47:56

这个怎么样?

链表类{

私人:

结构节点
{
    int 存储值;
    // ...
};

节点NodeReference;

const Node* const GetNodeReference(std::size_t Index) const
{
    返回&NodeReference;
}

公开:

int Get(std::size_t Index) const
{
    const Node *const node = GetNodeReference(Index);
    返回节点->StoredValue;
}

};

编辑:

正如您在评论中看到的那样

const Node* const GetNodeReference(std::size_t Index) const () ...

应更改为:

const Node* GetNodeReference(std::size_t Index) const () ...

How about this?

class LinkedList {

private:

struct Node
{
    int StoredValue;
    // ...
};

Node NodeReference;

const Node* const GetNodeReference(std::size_t Index) const
{
    return &NodeReference;
}

public:

int Get(std::size_t Index) const
{
    const Node *const node = GetNodeReference(Index);
    return node->StoredValue;
}

};

Edit:

As you can read in the comments

const Node* const GetNodeReference(std::size_t Index) const () ...

should be changed to:

const Node* GetNodeReference(std::size_t Index) const () ...

无言温柔 2024-10-26 08:47:56

我建议:

链表类{

私人:

结构节点
{
    int 存储值;
    // ...
};

节点NodeReference;

const 节点& GetNodeReference(std::size_t Index) const
{
    返回节点引用;
}

公开:

int Get(std::size_t Index) const
{
    const Node 节点 = GetNodeReference(Index);
    返回节点.StoredValue;
}

};

I suggest:

class LinkedList {

private:

struct Node
{
    int StoredValue;
    // ...
};

Node NodeReference;

const Node& GetNodeReference(std::size_t Index) const
{
    return NodeReference;
}

public:

int Get(std::size_t Index) const
{
    const Node node = GetNodeReference(Index);
    return node.StoredValue;
}

};

~没有更多了~
我们使用 Cookies 和其他技术来定制您的体验包括您的登录状态等。通过阅读我们的 隐私政策 了解更多相关信息。 单击 接受 或继续使用网站,即表示您同意使用 Cookies 和您的相关数据。
原文