将 const* 存储在 const 向量中

Question

我必须处理的相关接口代码包含两个函数，一个是检索对象，另一个是我必须将对象作为向量提交。 问题是，检索 function 返回const Object* ，但提交 function 需要const vector<Object*> 。

我知道这可以用const_cast<Object*>解决，但有没有不同的、更干净的方法？

这是演示该问题的代码：

#include <vector>

//////////// REPRESENTATIVE INTERFACE IMPLEMENTATION, DO NOT TOUCH ///////
struct Object{};

class Interface{
    public:
    size_t getNumObjects() const {return 10;}
    const Object* getObject(size_t index) const {return nullptr;}
};
const Interface interface;

void submitObjects(const std::vector<Object*> &objects);
//////////////////////////////////////////////////////////////////////

// Task: take all objects from 'interface' and submit them to 'submitObjects'.

int main(){

    std::vector<const Object*> objects;
    for(size_t i = 0; i < interface.getNumObjects(); i++){
        const Object* object = interface.getObject(i);
        objects.push_back(object);
    }

    submitObjects(objects); // ERROR: no known conversion from 'vector<const Object *>' to 'const vector<Object *>'

    return 0;
}

我能想出解决这个问题的唯一方法是使objects成为std::vector<Object*>并使用objects.push_back(const_cast<Object*>(object));插入对象。 ，但我觉得必须有更好的解决方案。

任何想法表示赞赏。

---

为什么这是一个有效问题的更多背景信息： const vector<Object*>只能提供const Object* ，如在其所有 getter 重载中所见，如下所示： https://de.cppreference.com/w/cpp /container/vector/operator_at

因此， vector<const Object*>几乎从不在接口中使用。 因此，将大量const Object*组合在一个大的const vector<Object*>中的想法是一个有效的概念，但如果没有const_cast似乎无法构造。

编辑：上面的陈述是不正确的，感谢澄清。 const std::vector<Object*>可以产生非常量指针，因为我对指针常量的理解是不正确的。

Answer 1

您的接口返回指向常量 object 的指针。 您想将那些常量 object 发送到需要可变对象的 function 中。

这不仅仅是关于未定义的行为，而是关于惊喜。

想象一下，实现该接口的人正在保留有关对象的计算值，并在调用可能发生变异的方法时标记为脏。 确实有一个令人信服的理由来返回指向常量对象的指针。 修改 const object 将破坏 class 不变量。

如果您将该常量发送到submitObjects并且您的 object 在那里发生变异，那么您在某种意义上说谎：接口向您发送常量对象并且您对其进行了变异。 你违反了合同。

如果submitObjects不改变其 arguments，则没有理由保持参数可变。

---

请注意关于 const 的混淆，这里有一个指向可变数据的指针的 const 向量的示例：

// const std::vector<int*>
auto const cannot_erase_or_add = std::vector<int*>{
    new int{1},
    new int{2},
    new int{3}
};

// Error!
// cannot_erase_or_add.push_back(new int{4});

// Error!
// cannot_erase_or_add.clear();

// operator[] return int*, because it's a vector of int*
int* one = cannot_erase_or_add[0];

// totally legal, int*, no const there
*one = 2;

另一方面，情况恰恰相反：

// std::vector<int const*>
auto can_erase_or_add = std::vector<int const*>{
    new int{1},
    new int{2},
    new int{3}
};

// Works
can_erase_or_add.clear();

// Works
can_erase_or_add.push_back(new int{4});

// operator[] return int const*, because it's a vector of int const*
int const* four = can_erase_or_add[0];

// Can't do that, pointer to const
// *four = 2;

Answer 2

您误解了文档/打字规则。 如果你有T = Object* ，那么const T不是const Object*而是Object* const 。 这就是 C 和 C++ 的工作原理。

因此，您断言“您无法从const vector<Object*>获得可变的 object 是错误的。您不能做的是修改向量或元素的值（即更改指针）。但是访问器返回对Object* const的引用Object* const ，所以仍然可以修改指向的对象：

void foo(const std::vector<int*>& v)
{
    (*v[0])++; // Increments the integer pointed to by the first vector element.
}

https://godbolt.org/z/HGIb20

这仅仅是因为const不具有传递性。 这是另一个例子：

struct X
{
    int* y;
};

void foo(const X& x)
{
    (*x.y)++;
}

https://godbolt.org/z/NmCwGt

---

鉴于此，您拥有的界面不允许您做任何事情。 您只获得了指向不可变对象的指针，但应该传递指向可变对象的指针（ submitObjects function 只承诺不修改容器，但保留修改对象的权利）。 这简直是不可能的。

const_cast可能是一个有效的选项，如果（这是一个非常重要的如果！）你知道 100% 的对象实际上并没有在任何地方被声明为const 。 但这既破坏了界面的意义，又是一种极其脆弱、笨拙的方法，在这种情况下你甚至不应该考虑。

Answer 3

您的选择是：

1. 更改submitObjects以接受std::vector<const Object*> 。
2. 或更改Interface::getObject以返回指向非常量Object的指针。
3. 或者使用const_cast ，如您所见。 如果可以，请避免这种情况。

如果submitObjects修改了指向的对象，那么 3. 如果不应该修改指向的对象（例如它们实际上是 const 对象）是危险的。 如果可以修改对象，则选择2。

如果submitObjects没有修改指向的对象，那么进行更改 1 应该没有问题。

如果submitObjects修改了指向的对象，而要修改的对象是不行的，那么你就有逻辑上的矛盾，除了不将指针传递给 function 之外没有其他解决方案。

不可能从const vector<Object*>中检索可变指针？

只有指针不能变异。 但是你可以改变指向的对象。 例子：

struct Object{ int member; };
Object o;
const vector<Object*> objects{&o};
objects[0]->member = 42; // well-defined

我在考虑 1.，但这意味着它将不再接受 std::vector，需要另一个重载

或者，您可以使用模板。 特别是，这可能是输入迭代器或范围的一个很好的用例。