c++ - 使用常量和非常量函数 - C++

Question

我有 3 个类(class)。在最简单的形式中，它看起来像，

class tree
{
public:
    tree_node* find_node(const std::string& text) {
       return factory.find(text);
    }
private:
    tree_node_factory factory;
}

class tree_node
{
public:
    tree_node(const std::string& text) : text_(text) {}

    const std::string& text() const {
       return text_;
    }

    void set_parent(const tree_node* new_parent);

private:
    std::string text_;
}

class tree_node_factory
{
public:
    tree_node* find(const std::string& text);
private:
    std::vector<tree_node*> allocated_nodes;
}

我不想让 tree 的用户修改由 find_node 等方法返回的 tree_node。所以我将 find_node 和 tree_node_factory::find 更改为，

const tree_node* find_node(const std::string& text) const {
    return factory.find(text);
}

const tree_node* find(const std::string& text) const;

问题是 tree 内部应该能够修改节点并处理 set_parent 等方法。但由于工厂仅返回 const 节点，我最终将 find 的另一个重载(非 const 版本)添加到工厂中。

tree_node* find(const std::string& text);

我想知道这是处理此类问题的正确方法吗？我看到代码在 const 和非 const 版本中重复出现。

有什么想法..？

Answer 1

Scott Meyers 的书 Effective C++ 中的第 3 项演示了一种删除此代码重复的方法。基本上，在您的非 const 函数中，您将向 this 添加 const，调用 const 版本，然后丢弃 const。这是安全的；虽然写入 const 变量会导致未定义的行为，因为 this 最初是非常量的，但没关系。

例子:

const std::string& operator[](size_t index) const
{
    // some other code

    // since `this` isn't really const, this is modifiable 
    return mData[index]; 
}

std::string& operator[](size_t index)
{
    return const_cast<std::string&> // (3) take const off result
            (static_cast<const my_type&> // (1) add const
            (*this)[index]); // (2) use const version

}

通常它会全部在一行上。您也可以为它制作一个实用程序。

注意一个警告:如果 const 版本返回一个“真正的”const 对象，这个方法显然会导致未定义的行为。返回值的常量性必须通过 this 引用的对象的常量性来反射(reflect)。这是损坏的代码:

const std::string& operator[](size_t index) const
{
    static const std::string constString = "Don't modify me.";

    if (index == 0)
    {
        // even though `this` isn't really const, this is NOT modifiable
        return constString; 
    }

    return mData[index - 1];
}

std::string& operator[](size_t index)
{
    return const_cast<std::string&> // (3) !!! take const off result !!!
            (static_cast<const my_type&> // (1)
            (*this)[index]); // (2)

}

在实践中，我们避免全局状态，所以这很少成为问题。无论如何，检查起来很简单。