如何用 cout 打印函数指针？

Question

我想使用 cout 打印出一个函数指针，发现它不起作用。 但是在我将函数指针转换为（void *）之后它起作用了，printf也是如此，带有％p，例如

#include <iostream>
using namespace std;

int foo() {return 0;}

int main()
{
    int (*pf)();
    pf = foo;
    cout << "cout << pf is " << pf << endl;
    cout << "cout << (void *)pf is " << (void *)pf << endl;
    printf("printf(\"%%p\", pf) is %p\n", pf);
    return 0;
}

我用g++编译得到如下结果：

cout cout printf("%p", pf) 为 0x100000b0c

那么 cout 对 int (*)() 类型做了什么？有人告诉我函数指针被视为布尔值，是真的吗？ cout 对 type (void *) 做了什么？

提前致谢。

编辑：无论如何，我们可以通过将函数指针转换为 (void *) 并使用 cout 打印出来来观察函数指针的内容。 但它不适用于成员函数指针，编译器抱怨非法转换。我知道成员函数指针不是简单的指针，而是一个比较复杂的结构，但是如何观察成员函数指针的内容呢？

Answer 1

实际上有一个

ostream & operator <<( ostream &, const void * );

符合您的预期 - 以十六进制输出。函数指针不可能有这样的标准库重载，因为它们有无数种类型。所以指针被转换为另一种类型，在这种情况下它似乎是一个 bool - 我不能随便记住这个规则。

编辑： C++ 标准规定：

4.12 布尔转换

1 算术右值， 枚举、指针或指向的指针 成员类型可以转换为 bool 类型的右值。

这是为函数指针指定的唯一转换。

Answer 2

关于您的编辑，您可以通过unsigned char 指针访问它来打印任何内容。指向成员函数的指针示例：

#include <iostream>
#include <iomanip>

struct foo { virtual void bar(){} };
struct foo2 { };
struct foo3 : foo2, foo { virtual void bar(){} };

int main()
{
    void (foo3::*p)() = &foo::bar;

    unsigned char const * first = reinterpret_cast<unsigned char *>(&p);
    unsigned char const * last = reinterpret_cast<unsigned char *>(&p + 1);

    for (; first != last; ++first)
    {
        std::cout << std::hex << std::setw(2) << std::setfill('0')
            << (int)*first << ' ';
    }
    std::cout << std::endl;
}

Answer 3

您可以将函数指针视为该函数机器代码中第一条指令的地址。任何指针都可以被视为bool：0 为假，其他一切为真。正如您所观察到的，当转换为 void * 并作为流插入运算符 (<<) 的参数给出时，将打印地址。 （严格来说，将指向函数的指针强制转换为 void * 是未定义的。）

没有演员，故事有点复杂。为了匹配重载函数（“重载解析”），C++ 编译器收集一组候选函数，并从这些候选函数中选择“最佳可行”函数，必要时使用隐式转换。皱纹是匹配规则形成偏序，因此多个最佳可行匹配会导致歧义错误。

按照优先顺序，标准转换（当然还有用户定义和省略号转换，不详述）是

• 完全匹配（即，无需转换）
• 促销（例如，int 到 float）
• 其他转化

最后一类包括布尔转换，任何指针类型都可以转换为bool：0（或NULL）是false，其他都是true。后者在传递给流插入运算符时显示为1。

要获取0，请将您的初始化更改为

pf = 0;

请记住，使用零值常量表达式初始化指针会产生空指针。

Answer 4

在 C++11 中，可以通过定义 operator<< 的可变参数模板重载来修改此行为（是否推荐是另一个主题）：

#include<iostream>
namespace function_display{
template<class Ret, class... Args>
std::ostream& operator <<(std::ostream& os, Ret(*p)(Args...) ){ // star * is optional
    return os << "funptr " << (void*)p;
}
}

// example code:
void fun_void_void(){};
void fun_void_double(double d){};
double fun_double_double(double d){return d;}

int main(){
    using namespace function_display;
    // ampersands & are optional
    std::cout << "1. " << &fun_void_void << std::endl; // prints "1. funptr 0x40cb58"
    std::cout << "2. " << &fun_void_double << std::endl; // prints "2. funptr 0x40cb5e"
    std::cout << "3. " << &fun_double_double << std::endl; // prints "3. funptr 0x40cb69"
}

Answer 5

如果您想查看它们的值，则将指向 (void*) 的指针转换为 cout 是正确的 (TM) 做法。

Answer 6

关于您的具体问题，

我们如何观察a的内容 成员函数指针？

答案是，除了将它们转换为 bool 以表示它指向或不指向某物外，您不能“观察”成员函数指针。至少不是以合规的方式。原因是标准明确不允许这样做：

4.12 脚注 57：

57) 转换规则 指向成员的指针（从指针到 基成员指向指向成员的指针 派生）与 指向对象的指针规则（从 派生的指针指向基的指针） （4.10，第 10 条）。这种反转是 确保类型安全所必需的。笔记 指向成员的指针不是 指向对象的指针或指向 函数和转换规则 此类指针不适用于 指向成员的指针。 特别是， 指向成员的指针无法转换 到一个空洞*。

例如，这里是示例代码：

#include <cstdlib>
#include <vector>
#include <algorithm>
#include <string>
#include <iostream>
using namespace std;

class Gizmo
{
public:
    void DoTheThing()
    {
        return;
    };


private:
    int foo_;
};

int main()
{
    void(Gizmo::*fn)(void) = &Gizmo::DoTheThing;

    Gizmo g;
    (g.*fn)();  // once you have the function pointer, you can call the function this way

    bool b = fn;
//  void* v = (void*)fn;    // standard explicitly disallows this conversion
    cout << hex << fn;
    return 0;
}

我注意到我的调试器 (MSVC9) 能够在运行时告诉我成员函数的实际物理地址，所以我知道必须有某种方法来实际获取该地址。但我确信它是不符合标准的、不可移植的，并且可能涉及机器代码。如果我要走这条路，我会先获取函数指针的地址（例如&fn），然后将其转换为void*，然后从那里开始。这还需要您知道指针的大小（在不同平台上有所不同）。

但我会问，只要你可以将成员函数指针转换为 bool 并评估指针的存在，为什么在实际代码中你需要地址？

大概最后一个问题的答案是“这样我就可以确定一个函数指针是否指向与另一个相同的函数”。很公平。您可以比较函数指针是否相等：

#include <cstdlib>
#include <vector>
#include <algorithm>
#include <string>
#include <iostream>
using namespace std;

class Gizmo
{
public:
    void DoTheThing()
    {
        return;
    };

    **void DoTheOtherThing()
    {
        return;
    };**


private:
    int foo_;
};

int main()
{
    void(Gizmo::*fn)(void) = &Gizmo::DoTheThing;

    Gizmo g;
    (g.*fn)();  // once you have the function pointer, you can call the function this way

    bool b = fn;
//  void* v = (void*)fn;    // standard explicitly disallows this conversion
    cout << hex << fn;

    **void(Gizmo::*fnOther)(void) = &Gizmo::DoTheOtherThing;

    bool same = fnOther == fn;
    bool sameIsSame = fn == fn;**

    return 0;
}

Answer 7

也许（有一次我对函数的地址保持交叉） 决定之一）））

#include <iostream>     
#include <stdlib.h>

void alexf();

int main()
{ 
    int int_output;

    printf("printf(\"%%p\", pf) is %p\n", alexf);

    asm( "movl %[input], %%eax\n"                
         "movl %%eax, %[output]\n" 
         : [output] "+m" (int_output)
         : [input] "r" (&alexf)
         : "eax", "ebx"
    );

        std::cout<<"" <<std::hex<<int_output <<""<<std::endl;
    return 0;
}

void  alexf() {  }

将指针传递给函数(&alexf) 或使用& 的其他指针使用约束r。让gcc 使用寄存器作为输入参数））。