在 C 语言中，如果我投射 &取消引用指针，我先执行哪一个有关系吗？

发布于 2024-10-10 20:31:54 字数 681 浏览 2 评论 0原文

在 C 中，您可以转换简单数据类型（例如 int、float）以及指向这些数据类型的指针。

现在我假设，如果您想从一种类型的指针转换为另一种类型的值（例如从 *float 到 int），则转换的顺序取消引用并不重要。即，对于变量 float* pf，您有 (int) *pf == *((int*) pf)。有点像数学中的交换律……

但事实似乎并非如此。我编写了一个测试程序：

#include <stdio.h>
int main(int argc, char *argv[]){
  float f = 3.3;
  float* pf = &f;
  int i1 = (int) (*pf);
  int i2 = *((int*) pf);
  printf("1: %d, 2: %d\n", i1, i2);
  return 0;
}

在我的系统上，输出是

1: 3, 2: 1079194419

因此，转换指针似乎与转换值的工作方式不同。

这是为什么？为什么第二个版本没有做我认为应该做的事情？

这是依赖于平台的，还是我以某种方式调用了未定义的行为？

原文

In C, you can cast both simple data types like int, float, and pointers to these.

Now I would have assumed that if you want to convert from a pointer to one type to the value of another type (e.g. from *float to int), the order of casting and dereferencing does not matter. I.e. that for a variable float* pf, you have (int) *pf == *((int*) pf). Sort of like commutativity in mathematics...

However this does not seem to be the case. I wrote a test program:

#include <stdio.h>
int main(int argc, char *argv[]){
  float f = 3.3;
  float* pf = &f;
  int i1 = (int) (*pf);
  int i2 = *((int*) pf);
  printf("1: %d, 2: %d\n", i1, i2);
  return 0;
}

and on my system the output is

1: 3, 2: 1079194419

So casting the pointer seems to work differently from casting the value.

Why is that? Why does the second version not do what I think it should?

And is this platform-dependent, or am I somehow invoking undefined behaviour?

分享到QQ

分享到微博

如果你对这篇内容有疑问，欢迎到本站社区发帖提问参与讨论，获取更多帮助，或者扫码二维码加入 Web 技术交流群。

发布评论

需要登录才能够评论，你可以免费注册一个本站的账号。

傻比既视感 2024-10-17 20:31:54

下面说的是获取 pf 处的浮点数并将其转换为整数。这里的转换是请求将浮点数转换为整数。编译器生成将浮点值转换为整数值的代码。（将浮点值转换为整数是“正常”的事情。）

int i1 = (int) (*pf);

下面说首先强制编译器认为 pf 指向整数（并忽略 pf 是指向浮点的指针这一事实），然后获取整数值（但它不是整数值）。这是一件奇怪而危险的事情。这种情况下的转换会禁用正确的转换。编译器在内存中执行位的简单复制（产生垃圾）。（并且也可能存在内存对齐问题！）

int i2 = *((int*) pf);

在第二个语句中，您没有“转换”指针。您正在告诉编译器内存指向什么（在本例中，这是错误）。

这两个语句正在做非常不同的事情！

请记住，c 有时使用相同的语法来描述不同的操作。

=============

请注意，double 是 C 中的默认浮点类型（数学库通常使用 double 参数）。

The following says get the float at pf and convert it to an integer. The casting here is a request to convert the float into an integer. The compiler produces code to convert the float value to an integer value. (Converting float values to integers is a "normal" thing to do.)

int i1 = (int) (*pf);

The following says first FORCE the compiler to think pf points to an integer (and ignore the fact that pf is a pointer to a float) and then get the integer value (but it isn't an integer value). This is an odd and dangerous thing to do. The casting in this case DISABLES the proper conversion. The compiler performs a simple copy of the bits at the memory (producing trash). (And there could be memory alignment issues too!)

int i2 = *((int*) pf);

In the second statement, you are not "converting" pointers. You are telling the compiler what the memory points to (which, in this example, is wrong).

These two statements are doing very different things!

Keep in mind that c some times uses the same syntax to describe different operations.

=============

Note that double is the default floating point type in C (the math library typically uses double arguments).

回复收藏 0 原文

天涯沦落人 2024-10-17 20:31:54

如果您先取消引用，然后再转换为 int，您将获得从 float 到 int 转换的常见（截断）行为。如果您首先转换为指向 int 的指针，然后取消引用，则该行为不是由标准定义的。通常它表现为将包含 float 的内存解释为 int。请参阅 http://en.wikipedia.org/wiki/IEEE_754-2008 了解如何实现有效。

回复收藏 0 原文

锦爱 2024-10-17 20:31:54

当然可以！强制转换告诉编译器如何查看内存的某些部分。然后，当您访问内存时，它会尝试根据您告诉它如何查看数据来解释其中的数据。使用以下示例更容易理解。

int main()
{
    char A[] = {0, 0, 0, 1 };
    int p = *((int*)A);
    int i = (int)*A;
    printf("%d %d\n", i, p);
    return 0; 
}

32 位小端机器上的输出将为 0 16777216。这是因为 (int*)A 告诉编译器将 A 视为指向整数的指针，因此当您取消引用 A 时，它会查看从 A 开始的 4 个字节（作为 sizeof(int ) == 4)。考虑字节顺序后，4 个字节的内容计算为 16777216。另一方面，*A 取消引用 A 以获得 0 和 (int )*A 将其转换为 0。

Of course it does! Casting tells the compiler how to look at the some section of memory. When you then access the memory, it tries to interpret the data there based on how you told it look at it. It's easier to understand it using the following example.

int main()
{
    char A[] = {0, 0, 0, 1 };
    int p = *((int*)A);
    int i = (int)*A;
    printf("%d %d\n", i, p);
    return 0; 
}

The output on a 32-bit little endian machine will be 0 16777216. This is because (int*)A tells the compiler to treat A as a pointer to integer and hence when you dereference A, it looks at the 4 bytes starting from A (as sizeof(int) == 4). After accounting for the endian-ness, the content of the 4 bytes evaluated to 16777216. On the other hand, *A dereferences A to get 0 and (int)*A casts that to get 0.

回复收藏 0 原文