interpret_cast指针的向量到基类的指针的向量

reinterpret_cast vector of pointers to vector of pointers to base class

本文关键字：向量 指针 基类 cast interpret      更新时间：2023-10-16

考虑以下代码

#include <algorithm>
#include <iostream>
#include <memory>
#include <vector>
struct Base {
    int x;
    Base(int x) : x(x) {}
};
struct Derived : public Base {
    int y, z;
    Derived(int x) : Base(x), y(x + 1), z(x + 2) {}
};
void update(const std::vector<std::shared_ptr<const Base>>& elements) {
    for (const auto elem : elements) {
        std::cout << elem->x << "n";
    }
}
int main(int, char**) {
    std::vector<std::shared_ptr<Derived>> elements(4);
    {
        int ctr = 0;
        std::generate(begin(elements), end(elements), [&ctr]() { return std::make_shared<Derived>(++ctr); });
    }
//    update(elements); // note: candidate function not viable: no known conversion from 'vector<shared_ptr<Derived>>' to 'const vector<shared_ptr<const Base>>' for 1st argument
    update(reinterpret_cast<std::vector<std::shared_ptr<const Base>>&>(elements));  // ok
    return 0;
}

我的问题是，使用reinterpret_cast从std::vector<std::shared_ptr<Derived>>转换为std::vector<std::shared_ptr<const Base>>&是否可行并被标准所接受。

我已经用clang-3.8和gcc-6.1用-fsanitize=undefined编译了代码，看起来还可以。但是，我似乎找不到关于cppreference的正确解释。

当然，我可以很容易地创建一个appropriate函数，但它比一行interpret_cast长，并且需要一个临时向量。

void update(const std::vector<std::shared_ptr<Derived>>& elements) {
    std::vector<std::shared_ptr<const Base>> casted(elements.size());
    std::copy(begin(elements), end(elements), begin(casted));
    update(casted);
}

模板和容器（我将shared_ptr视为容器的一种特殊形式）在C++中不是协变的。这意味着，如果有两种类型Base和Derived < Base以及一种template<typename T> class X {};，那么X<Base>和X<Derived>是两种完全不同的东西，并且没有任何形式的关系。

在您的例子中，您有一个类型为std::vector<std::shared_ptr<Derived>>的对象，然后创建一个std::vector<std::shared_ptr<const Base>>&来访问它。我认为这有两个问题：

  1. 您将类型为vector的对象强制转换为引用类型。我真的很想知道为什么这样有效
  2. 您可以通过不相关的不同类型的引用来访问对象。我认为这违反了严格的别名规则，因此是未定义的行为

如果你用gcc -fstrict-aliasing编译代码，编译器会认为你的程序符合规则并对其进行优化。它会生成一个警告：

> Start prog.cc: In function 'int main(int, char**)': prog.cc:33:80:
> warning: dereferencing type-punned pointer will break strict-aliasing
> rules [-Wstrict-aliasing]
>      update(reinterpret_cast<std::vector<std::shared_ptr<const Base>>&>(elements));  // ok
像这样的reinterpret_cast是未定义的行为。当从Derived*转换为Base*需要调整指针时，代码将中断。当Derived使用多重继承并且Base不是它的第一个基类时，这种情况很可能发生。 
struct Derived : public X, public Base { ... };
Derived* d = new Derived;
Base* b = d; // this is no longer a "no-op", since the Base sub-object
             // of Derived is not at offset 0:
             //
             // d  b
             // |  |
             // v  v
             // [Derived]
             // [X][Base]

如果您的目标只是使其以最简洁的方式工作，而不是避免通过临时向量进行转换，那么在这种特殊情况下，您可以使用本答案中提出的container_cast实用程序。

update(container_cast(elements));
相关文章：