众所周知,优化C(也可能是C ++)编译器会破坏执行此类操作的代码:
type1 foo, *pfoo;
type2_incompatible_with_type1 *pbar;
/* ... */
pfoo = &foo;
pbar = (type2_incompatible_with_type1*)pfoo;
/* ... */
while(condition){
change_type2_value(pbar);
/* ... */
use_type1_value_which_should_have_changed(*pfoo);
/* ... */
}
其中change_type2_value看起来像这样:
void change_type2_value(type2_incompatible_with_type1 *pbar){
*pbar = SOME_VALUE;
}
编译器可能会考虑pfoo
和pbar
个不同的指针,尽管它们指向相同的内存位置,因此,每次更改时都不会重新加载*pfoo
的内容pbar
指向的值,即使它也会更改pfoo
指向的内存。
但是,如果我们这样做:
type1 foo, *pfoo;
/* ... */
pfoo = &foo;
/* ... */
while(condition){
change_type2_value((type2_incompatible_with_type1*)pfoo);
/* ... */
use_type1_value_which_should_have_changed(*pfoo);
/* ... */
}
虽然解除引用会在change_type2_value
函数中发生,但这在技术上仍会打破严格的别名,因为实际上我们的指针指向不同的类型。但是,真实编译器使用的严格别名优化是否会破坏此代码?
我认为如果编译器退出当前函数的范围以查看另一个函数中应该发生的事情,只是为了弄清楚它是否应重新加载指向的内存,这是可能的。已传递给它的变量。这对我来说似乎不太可行。
或者有可能一个真正的编译器可以做一些令人讨厌的事情,因为如果我们将它作为强制转换传入它,那么所讨论的函数将不更改指针所指向的内存指向不兼容类型的指针?
答案 0 :(得分:4)
严格遵守?否。
请看以下内容:
void bar(){
int x=7;
foo();
printf("%d\n",x);
}
x
打印的价值是多少?它是foo()
修改x
的合法途径。
怎么样
void bar(int* x){
*x=7;
foo();
printf("%d\n",*x);
}
所有赌注都已关闭。 foo()
可以通过其他方式访问x
指向的地址。我们不能说,编译器很可能没有像我们这里那样继续下去。
它取决于foo()
的定义位置和方式以及编译器的整体性。
例如,foo()
是inline
等等。
现在你所做的是在传递给change_type2_value(.)
之前强加,因为它不严格符合取消引用编译器仍然符合的指针假设change_type2_value(.)
没有取消引用其论点,如果它是一个局部变量(你的代码片段没有明确说明),它绝对可以假设它没有改变。
下一步是个坏主意
如果您通过以下呼叫替换了该呼叫,该怎么办?
void do_secret_stuff_with_type1(type1* t1){
type2_incompatible_with_type1* pbar = (type2_incompatible_with_type1*)pfoo;
change_type2_value((type2_incompatible_with_type1*)pfoo);
}
type1 foo, *pfoo;
/* ... */
pfoo = &foo;
/* ... */
while(condition){
do_secret_stuff_with_type1(pfoo); //Looks innocent, right?
/* ... */
use_type1_value_which_should_have_changed(*pfoo);
/* ... */
}
同样如此。它确实使编译器更难发现正在发生的事情。如果do_secret_stuff_with_type1()
在单独的翻译单元中定义,则会逐渐增加您将编译器混淆的可能性。
结束坏主意
然而,这种黑客攻击几乎肯定是一个可怕的想法。 你为什么要这样做? 忘记别名你在做什么,在不兼容的类型之间进行投射将产生一个有用的程序?
对于任何真实案例,几乎总是一个解决方案,涉及通过unsigned char*
访问对象或使用memcpy()
进行复制,在某些情况下使用union
变为不符合程序编入符合标准的程序。