为什么 std::cout 将 volatile 指针转换为 bool？

Question

如果您尝试 cout 指向 volatile 类型的指针，甚至是您通常期望 cout 打印字符串的 volatile char 指针，您将改为简单地得到 '1'（假设指针不为 null 我认为）。我假设输出流 operator

示例代码：

#include <iostream>
#include <cstring>

int main()
{
    char x[500];
    std::strcpy(x, "Hello world");

    int y;
    int *z = &y;

    std::cout << x << std::endl;
    std::cout << (char volatile*)x << std::endl;

    std::cout << z << std::endl;
    std::cout << (int volatile*)z << std::endl;

    return 0;
}

输出：

Hello world
1
0x8046b6c
1

Answer 1

不是答案

这只是问题和答案的措辞问题。问题的出现是由于无法将 指向 volatile 对象的指针转换为 void 指针，而不是 volatile 指针。

相当重要的区别在于哪个存储元件是易失性的。问题中，指针不是volatile的（可以缓存，改变的时候不用刷到内存），而是指向的内存：

int volatile * p = f();
p++;      // this does not affect the perceived state of the c++ memory model
++p;
*p = 5;   // this changes the perceived state

之所以重要，是因为对于指向内存的 volatile 指针，该指针本身是需要特殊处理的指针。

void foo( int * );

int * volatile p = f();  // 1
foo(p);                  // 2
int volatile * q = f();
//foo(q);    // error, cannot convert pointer to volatile to pointer to non-volatile
*q = 5;                  // 3
q = 0;                   // 4

在上面的代码中，标记为 1 和 2 的操作一直到内存。 [1] 中的赋值必须转储到内存中。即使p 的值在寄存器中，它也会从[2] 处的内存中加载。标记为[3]的操作修改了q指向的值，即volatile，并将一直到主存，而操作[4]只影响指针，而不是volatile本身，并且作为这不是 c++ 内存模型可感知状态的一部分，可以在寄存器中执行（请注意，编译器可以优化掉 q 并在寄存器中执行操作，而不能优化 p。

Answer 2

我认为问题不是指向 volatile 类型的指针的显式重载，而是指向 volatile 类型的指针缺少重载。编译器无法从指针中隐式删除 volatile 限定符，因此它会检查可用的重载，选择 operator

Answer 3

我认为原因是 volatile 指针不能隐式转换为 void *。这在标准的附录 C 中，其基本原理是类型安全。

更改：仅指向非 const 和 非易失性对象可能是隐式的 转换为 void* 理由：这 提高类型安全性。

因此，您无需转换为 void *（将以十六进制打印），而是将“默认”转换为 bool。

Answer 4

ostream::operator<< 具有以下重载：

ostream& operator<< (bool val );
ostream& operator<< (const void* val );

当你传入一个 volatile 指针时，第二个重载不能应用，因为 volatile 指针不能在没有显式转换的情况下转换为 non-volatile。但是，任何指针都可以转换为bool，所以选择第一个重载，你看到的结果是1或者0。

因此，这样做的真正原因不是代表标准委员会的有意决定，而只是标准没有指定采用 volatile 指针的重载。