20

给定以下代码：

#include <iostream>

using std::cout;

class A {
    public:
        virtual ~A() {}
        int x,y,z;
};

int main (void)
{
    std::cout<<&A::x;
    std::cout<<&A::y;
    std::cout<<&A::z;
}

输出是：

111

输出的含义是什么？为什么是1？是否有充分的理由通过指针（没有创建的对象）访问类成员？

编辑 - 使用：

printf("%p",&A::x);
printf("%p",&A::y);
printf("%p",&A::z);

打印：4、8 和 C。

我猜现在它更有意义了..（字节）但是，这有什么用吗？

4

2 回答 2

30

没有operator<<(std::ostream&, T)为T = &C::m. 通常你会得到一个错误。

但相反，有一个 forT = bool和一个从成员指针到 的隐式转换bool。所以你看到的输出只是那些指针不为空（被转换为true）的结果。

试试这个，例如：

#include <iomanip>
#include <iostream>

struct A
{
    int x, y, z;
};

int main()
{
    std::cout << std::boolalpha; // print boolean values as text

    std::cout << &A::x << std::endl;
    std::cout << &A::y << std::endl;
    std::cout << &A::z << std::endl;
}

输出：

真的
真的
真的

请注意，在代码printf("%p", &A::X)中，您有未定义的行为。

说明符的值%p必须是 a void*，并且没有从成员指针到 a 的转换void*。相反，你有别名（类型双关语） to void*，这是未定义的行为。（想象一下sizeof(&A::x)4 岁，而sizeof(void*)64 岁；没有人说这不可能。）

您只需要接受并非所有指针都可以视为整数偏移量的想法。我们甚至可以打印一个指针是实现定义的：它可以为 null 打印“apple”，为一个值打印“pear”，如果（哑）实现想要打印另一个值，则为另一个“milk”。我之前已经谈到了值和它们的表示之间的这种差异。

在这种情况下，该值根本没有输出。没关系，并非所有值都有有意义的打印输出。您最多可以打印出各个位：

#include <climits>
#include <iostream>
#include <type_traits>

template <typename T>
auto print_bits(const T& value)
    -> typename std::enable_if<std::is_standard_layout<T>::value>::type
{
    // it's okay to alias a standard-layout type as a sequence of bytes:
    const auto valueAsBytes = reinterpret_cast<const unsigned char*>(&value);

    for (std::size_t byte = 0; byte < sizeof(T); ++byte)
    {
        // print in reverse order
        const std::size_t byteIndex = sizeof(T) - byte - 1;

        const unsigned char byteValue = valueAsBytes[byteIndex];

        for (std::size_t bit = 0; bit < CHAR_BIT; ++bit)
        {
            // print in reverse order
            const std::size_t bitIndex = CHAR_BIT - bit - 1;

            const bool bitValue = (byteValue & (1U << bitIndex)) != 0;

            std::cout << (bitValue ? 1 : 0);
        }

        std::cout << ' ';
    }

    std::cout << std::endl;
}

（我以相反的顺序打印字节和位，因为在我的架构中，这会将最低有效位放在右侧。我更喜欢以这种方式查看二进制值。）

这给出了：

struct A
{
    int x, y, z;
};

int main()
{
    // example:
    for (unsigned i = 0; i < 64; ++i)
        print_bits(i);

    std::cout << std::endl;

    // member-pointers:
    print_bits(&A::x);
    print_bits(&A::y);
    print_bits(&A::z);
}

输出：

00000000000000000000000000000000000000000000000000 来 症
0000000000000000000000 来 州
_



00000000 00000000 00000000 00000000
00000000 00000000 00000000 00000100
00000000 00000000 00000000 00001000

无法保证您看到的成员指针。

于 2013-04-16T14:39:10.837 回答
2

&A::x创建一个指向类成员的指针A。在某种程度上，指向成员的指针是该成员在类中的“位置”的表示。这些数字的确切含义取决于特定的实现。我猜想在您的特定实现中，这意味着x在类中的索引 1 上（虚函数表指针在索引 0 上）。 编辑实际上，GManNickG 的回答表明我对这个假设有误，它只是打印指向成员的指针隐式转换为bool.

请注意，指向成员的指针不是经典意义上的指针。您不能直接取消引用指向成员的指针。你总是需要一个指向对象的指针/引用来配合它。示例（使用您的课程）：

int main()
{
  int A::*pm;  // pm is a pointer to member of A of type int
  A a;
  pm = &A::x;
  std::cout << a.*pm; //will output a.x
  pm = &A::y;
  std::cout << a.*pm; //will output a.y
  A *pa = &a;
  std::cout << pa->*pm;  //will output pa->y
}
于 2013-04-16T14:38:01.150 回答