问题描述
假设我有
class A { public: void print(){cout<<"A"; }};
class B: public A { public: void print(){cout<<"B"; }};
class C: public A { };
如何在内存级别实现继承?
How is inheritance implemented at the memory level?
C
复制 print()
代码到自身还是有指向它的指针在 A
代码的一部分?
Does C
copy print()
code to itself or does it have a pointer to the it that points somewhere in A
part of the code?
当我们覆盖之前的定义时,如何发生同样的事情,例如在 B
(在内存级别)?
How does the same thing happen when we override the previous definition, for example in B
(at the memory level)?
推荐答案
允许编译器然而他们选择实施这个。但它们通常遵循CFront的旧实现。
Compilers are allowed to implement this however they choose. But they generally follow CFront's old implementation.
考虑:
#include <iostream>
class A {
void foo()
{
std::cout << "foo\n";
}
static int bar()
{
return 42;
}
};
A a;
a.foo();
A::bar();
编译器将最后三行更改为类似于:
The compiler changes those last three lines into something similar to:
struct A a = <compiler-generated constructor>;
A_foo(a); // the "a" parameter is the "this" pointer, there are not objects as far as
// assembly code is concerned, instead member functions (i.e., methods) are
// simply functions that take a hidden this pointer
A_bar(); // since bar() is static, there is no need to pass the this pointer
从前时间我会猜到这是在每个 A
对象中创建的指针到函数处理的。但是,这种方法意味着每个 A
对象将包含相同的信息(指向同一函数的指针),这会浪费大量空间。编译器很容易处理这些细节。
Once upon a time I would have guessed that this was handled with pointers-to-functions in each A
object created. However, that approach would mean that every A
object would contain identical information (pointer to the same function) which would waste a lot of space. It's easy enough for the compiler to take care of these details.
当然,那不是你问的那个。但是我们可以将它扩展到继承,这是你所期望的:
Of course, that wasn't really what you asked. But we can extend this to inheritance, and it's what you'd expect:
class B : public A {
void blarg()
{
// who knows, something goes here
}
int bar()
{
return 5;
}
};
B b;
b.blarg();
b.foo();
b.bar();
编译器将最后四行变为:
The compiler turns the last four lines into something like:
struct B b = <compiler-generated constructor>
B_blarg(b);
A_foo(b.A_portion_of_object);
B_bar(b);
关于虚拟方法的说明
事情得到当你谈论虚拟
方法时,有点棘手。在这种情况下,每个类都会获得一个特定于类的指针函数数组,每个虚拟
函数都有一个这样的指针。该数组称为vtable(虚拟表),每个创建的对象都有一个指向相关vtable的指针。通过查找要在vtable中调用的正确函数来解析对 virtual
函数的调用。
Notes on virtual methods
Things get a little trickier when you talk about virtual
methods. In that case, each class gets a class-specific array of pointers-to-functions, one such pointer for each virtual
function. This array is called the vtable ("virtual table"), and each object created has a pointer to the relevant vtable. Calls to virtual
functions are resolved by looking up the correct function to call in the vtable.
这篇关于如何在内存级别实现继承?的文章就介绍到这了,希望我们推荐的答案对大家有所帮助,也希望大家多多支持!