为什么这个静态 C++ 强制转换有效？

Question

想象一下这段代码：

class Base {
 public:
  virtual void foo(){}
};

class Derived: public Base {
  public:
    int i;
    void foo() override {}
    void do_derived() {
      std::cout << i;
    }
};

int main(){
  Base *ptr = new Base;
  Derived * static_ptr = static_cast<Derived*>(ptr);
  static_ptr->i = 10;  // Why does this work?
  static_ptr->foo(); // Why does this work?
  return 0;
}

为什么我在控制台上得到结果 10？我想知道，因为我认为 ptr 是指向基础对象的指针。因此该对象不包含 int i 或方法do_derived()。是否会自动生成新的派生对象？

当我也在 Base 类中声明了一个虚拟的do_derived() 方法时，选择了这个，但是为什么呢？

Answer 1

int* i = new int{1};
delete i;
std::cout << *i << std::endl;

如果工作的定义是代码将编译和执行，这也将“工作”。

但是，这显然是未定义的行为，并且无法保证会发生什么。

---

在您的情况下，代码编译为static_cast 不会执行任何检查，它只是转换指针。访问尚未分配和初始化的内存仍然是未定义的行为。

Answer 2

正如 cmets 中提到的，“碰巧做到了你所期望的”与“工作”不同。

让我们做一些修改：

#include <iostream>
#include <string>

class Base{
public:
    virtual  void foo(){
        std::cout << "Base::foo" << std::endl;
    }
};

class Derived: public Base{
public:
    int a_chunk_of_other_stuff[1000000] = { 0 };
    std::string s = "a very long string so that we can be sure we have defeated SSO and allocated some memory";
    void foo() override {
        std::cout << "Derived::foo" << std::endl;
    }
    void do_derived() {
        std::cout << s << std::endl;
    }
};

int main(){
    Base *ptr = new Base;
    Derived * static_ptr = static_cast<Derived*>(ptr);
    static_ptr -> foo(); // does it though?
    static_ptr -> do_derived(); // doesn't work?
    static_ptr->a_chunk_of_other_stuff[500000] = 10;  // BOOM!
    return 0;
}

样本输出：

Base::foo

Process finished with exit code 11

在这种情况下，没有任何操作符合我们的预期。对数组的赋值导致了段错误。

Answer 3

为什么这个静态转换有效？

因为静态转换是编译时检查器。 Base 和 Derived 之间存在关系。由于它有关系，静态演员相信是这种关系，也相信是程序员。所以作为一个程序员，你应该确保 Base 对象不应该被静态转换为派生类对象。

Answer 4

声明：

Base *ptr = new Base;

并不总是分配sizeof(Base) - 它可能会分配更多的内存。即使它确实分配了确切的sizeof(Base) 字节，也不一定意味着此范围之后的任何字节访问（即sizeof(Base)+n，n>1）都是无效的。

因此我们假设 Base 类的大小为 4 字节（由于大多数编译器实现中的虚函数表，在 32 位平台上）。但是，new 运算符、堆管理 API、操作系统的内存管理和/或硬件确实为此分配分配了 16 个字节（假设）。这使得额外的12 字节有效！它使以下语句有效：

static_ptr->i = 10;

从现在开始，它尝试在前 4 个字节（多态类的大小 Base）之后写入 4 个字节（通常为sizeof(int)）。

函数调用：

static_ptr->foo();

只需调用Derived::foo，因为指针的类型是Derived，并且没有任何问题。编译器必须调用Derived::foo。 Derived::foo 方法甚至不尝试访问派生类（甚至基类）的任何数据成员。

你打过电话吗：

static_ptr->do_derived();

正在访问派生的i 成员。它仍然有效，因为：

• 函数调用始终有效，直到方法尝试访问数据成员（即从this 指针访问某些内容）。
• 由于内存分配（UD 行为）

请注意，以下是完全有效的：

class Abc
{
public:
void foo() { cout << "Safe"; }
};

int main()
{
   Abc* p = NULL;
   p->foo(); // Safe
}

调用它有效，因为它转换为：

    foo(NULL);

foo 在哪里：

void foo(Abc* p)
{
    // doesn't read anything out of pointer!
}