将派生**转换为基本**和派生*转换为基本* [英] Converting Derived** to Base** and Derived* to Base*
问题描述
好的,我正在阅读 FQA中的此条目 a>处理将 Derived **
转换为 Base **
以及为什么它被禁止的问题;我得到的问题是,你可以分配一个基础*
不是一个 Derived *
禁止。
Ok, I was reading through this entry in the FQA dealing about the issue of converting a Derived**
to a Base**
and why it is forbidden, and I got that the problem is that you could assign to a Base*
something which is not a Derived*
, so we forbid that.
到目前为止,这么好。
但是,如果我们深入地应用这个原则,我们禁止这样的例子?
But, if we apply that principle in depth, why aren't we forbidding such example?
void nasty_function(Base *b)
{
*b = Base(3); // Ouch!
}
int main(int argc, char **argv)
{
Derived *d = new Derived;
nasty_function(d); // Ooops, now *d points to a Base. What would happen now?
}
我同意 nasty_function
做一些愚蠢的事情,所以我们可以说,让那种转换是好的,因为我们启用有趣的设计,但我们可以说,也为双重间接:你有一个 Base **
,但你不应该给它的引用分配任何东西,因为你真的不知道 Base **
到哪里,就像 Base *
。
I agree that nasty_function
does something idiotic, so we could say that letting that kind of conversion is fine because we enable interesting designs, but we could say that also for the double-indirection: you got a Base **
, but you shouldn't assign anything to its deference because you really don't know where that Base **
comes, just like the Base *
.
所以,问题:什么是特殊的额外级间接?也许关键是,只需要一个间接级别,我们可以使用虚拟 operator =
来避免这种情况,而同样的机制不可用于普通指针? / p>
So, the question: what's special about that extra-level-of-indirection? Maybe the point is that, with just one level of indirection, we could play with virtual operator=
to avoid that, while the same machinery isn't available on plain pointers?
推荐答案
nasty_function(d); // Ooops, now *d points to a Base. What would happen now?
不,它指向派生
。该函数简单地更改了现有 Derived
对象中的 Base
子对象。请考虑:
No, it doesn't. It points to a Derived
. The function simply changed the Base
subobject in the existing Derived
object. Consider:
#include <cassert>
struct Base {
Base(int x) : x(x) {}
int x;
};
struct Derived : Base {
Derived(int x, int y) : Base(x), y(y) {}
int y;
};
int main(int argc, char **argv)
{
Derived d(1,2); // seriously, WTF is it with people and new?
// You don't need new to use pointers
// Stop it already
assert(d.x == 1);
assert(d.y == 2);
nasty_function(&d);
assert(d.x == 3);
assert(d.y == 2);
}
d
t magically成为 Base
,是吗?它仍然是派生
,但 Base
部分更改了。
d
doesn't magically become a Base
, does it? It's still a Derived
, but the Base
part of it changed.
在图片中:)
这是 Base
和 Derived
对象如下所示:
当我们有两个间接级别时,它不工作,因为被分配的东西是指针:
When we have two levels of indirection it doesn't work because the things being assigned are pointers:
请注意,尝试更改 Base
或 Derived
对象:只有中间的指针。
Notice how neither of the Base
or Derived
objects in question are attempted to be changed: only the middle pointer is.
但是,当你只有一个间接层次,代码修改对象本身,在对象允许的方式禁止通过从 Base
中隐藏,隐藏或删除赋值运算符):
But, when you only have one level of indirection, the code modifies the object itself, in a way that the object allows (it can forbid it by making private, hiding, or deleting the assignment operator from a Base
):
注意没有指针被改变这里。这类似于改变对象的一部分的任何其他操作,例如 d.y = 42;
。
Notice how no pointers are changed here. This is just like any other operation that changes part of an object, like d.y = 42;
.
这篇关于将派生**转换为基本**和派生*转换为基本*的文章就介绍到这了,希望我们推荐的答案对大家有所帮助,也希望大家多多支持IT屋!