c++ - 智能指针的 const 正确性

Question

我试图更好地理解 const-correctness 是如何工作的，更具体地说，在处理其成员基于 containers 和 smart pointers 的类时。我想无论类成员如何，const-correctness 属性都是相同的。但是，由于我很难清楚地了解发生了什么，我决定向你征求意见。

所以，这是上下文。我有一个 ShapeContainer 类，它有一个智能指针 vector 作为私有(private)类成员。Shape 类是抽象类，具有以下虚函数 virtual float doSomething();，然后由其派生类重新定义。请注意，它是一个非常量类函数。代码的相关部分如下:

class ShapeContainer{

    public:

        typedef std::shared_ptr<Shape> ShapePtr;
        typedef std::vector<ShapePtr> ShapePtrContainer;

        // .......
        const ShapePtr & operator[]( int ) const { return m_vect[index]; }; // const version
        //  ShapePtr & operator[]( int ) { return m_vect[index]; }; // non-const version
        // .......

    private:

        ShapePtrContainer m_vect;
};

class Shape{

    public:
        // ...
        virtual float doSomething() = 0;

};

这是我的问题。

Q1。为什么允许我按以下方式调用 doSomething() 函数:int index = 0; float tmp = container1[index]->doSomething();(有 ShapeContainer container1=createBasicShapes();)？
据我了解，在调用 const ShapePtr operator[] const 函数后，我们将获得一个指向 Shape 对象的 const 指针，但是doSomething() 虚拟函数不是常量。那么，对 const 对象的引用如何调用非常量函数？

Q2。通过调用 doSomething() 函数，如前所述 (float tmp =container1[index]->doSomething();) 和 添加一个operator[] 的非常量 版本，这个后者然后调用重载版本而不是 const-version 版本。为什么会这样？

现在，我没有 ShapeContainer 类，而是有了一个名为 ShapeContainerInfo 的新类，它仍然有一个 vector 但中间 ShapeInfo 类(具有作为类成员的智能指针)。

class ShapeContainerInfo{

    public:

        typedef std::vector<ShapeInfo> ShapeContainer;
        const ShapeInfo & operator []( int index) const { return m_vect[index]; };
        // ShapeInfo & operator []( int index) { return m_vect[index]; }; // non-const version

    private:
        ShapeContainer m_vect;
};

class ShapeInfo{

    public:

        typedef std::shared_ptr<Shape> ShapePtr;

        // ...
        float doSomething(){ return m_ShapePtr->doSomething(); };

    private:

        ShapePtr m_ShapePtr;
        int m_nID;
};

Q3。当我调用 float tmp = container2[i].doSomething(); 时，出现以下编译器错误:error C2662: 'ShapeInfo::doSomething' : cannot convert 'this' pointer from 'const ShapeInfo' 到 'ShapeInfo &'。
但是，当我添加重载的 operator [] 的 non-const 版本时，编译器错误消失了。那么，为什么我真的需要 non-const operator[] 用于 ShapeContainerInfo 而不是 ShapeContainer？

Q4。如果 ShapeContainerInfo 的 m_vect private 成员现在设置为 public 成员且仅 operator[] 的 const 版本已定义(不是 non-const 版本)，没有编译器错误消息。为什么这个？例如将 m_vect 设置为公共(public)类成员后:float tmp = info.m_vect[i].doSomething();

问题 5。我怎样才能正确定义 ShapeInfo 和 ShapeContainerInfo 类，这样我只需要定义 operator[ 的 const-version ] 并且仍然能够调用 float doSomething() 函数？

如果您对整个示例代码感兴趣，请找到它 here .
总是欢迎澄清，建议:-)谢谢!

Answer 1

Q1:shared_ptr 是const，并不代表指向的对象是const。为此，您需要 shared_ptr<const Shape> .

问题 2:由于您的 ShapeContainer 不是 const，非 const 函数更匹配，因此调用它而不是 const 版本。

问题 3:vector 将其常量传播到其元素。 shared_ptr 没有。这符合数组和原始指针的行为。 const 数组的元素是 const。 const 指针指向的东西不是(必然)const。

Q4:你是说这不会产生错误吗？

ShapeContainerInfo info;
info[0].doSomething();

请澄清，因为那应该是一个错误。

Q4:好的，所以您是说这不会产生错误:

ShapeContainerInfo info;
info.m_vect[0].doSomething();

也不应该。 vector 不是常量。只有在 const 成员函数内部， vector (和所有其他成员)才被视为 const。

问题 5:使 m_vect 成为唯一指针的 vector 。在 const 函数内部， vector 本身是 const，唯一指针也是 const。但是唯一指针指向的对象将是可变的。

举个例子，这个类中的set函数是不合法的:

struct Foo
{
    void set(int index, int value) const
    {
        v[index] = value;
    }

    std::vector<int> v;
};    

但是这个是:

struct Foo
{
    void set(int index, int value) const
    {
        *v[index] = value;
    }

    std::vector<std::unique_ptr<int>> v;
};