第七根弦的技术博客

__func__是C99标准里面预定义标识符, 它是一个static const char[],
会在每一个使用__func__的函数里隐式定义.

下面是ISO9899里的例子
#include <stdio.h>
void myfunc(void)
{
printf(“%s/n”, __func__);
/* … */
}

输出: myfunc

据我所知好像只有GCC才支持这个标识符, 其它编绎器厂商要么就没支持要么是扩展为其它. 如VC7里就只有__FUNCTION__和GCC里__PRETTY_FUNCTION__.
1,然而这个特性我所感兴趣的是在C++里它能输出什么?
2,它是否能用于构造函数的初始化列表?
3,它是否能用于默认参数?
4,除用于异常信息或DEBUG信息外还有什么用途?
5,应该用标准的还是用扩展的标识符?

第一个问题比较好解决,只要写些测试代码就行了.
因为环境的关系我只能用GCC 3.4.2做测试, 在GCC里除__func__还有
__FUNCTION__和__PRETTY_FUNCTION__, 前者两个所输出的和上面那个例的的结果一样只有一个函数名, 而后者则比较长细地列出函数的信息.

下面是测试在C++里__func__这个特性的输出.
#include <cstdio>
#include <cstdlib>

#define EXTERN_2

#define _INFO(n) puts(n)
#ifdef STANDARD
#define INFO() _INFO(__func__)
#endif
#ifdef EXTERN_1
#define INFO() _INFO(__FUNCTION__)
#endif
#ifdef EXTERN_2
#define INFO() _INFO(__PRETTY_FUNCTION__)
#endif
namespace _private{
class TestBase{
public:
virtual ~TestBase(){}
};

class Test: public TestBase{
public:
Test(){INFO();}

template<class T>
Test(T){INFO();}

Test(int, …){INFO();}

~Test(){INFO();}

static void bar(){INFO();}

template<class T>
operator T()const{
INFO();
return T();
}

friend __stdcall void foo(TestBase& t){INFO();};

struct Widget{};
};
}

int main(){
using namespace _private;
using namespace std;
{
Test t1;
Test t2(0, ‘a’, ‘b’);
Test const t3=Test(0.);
Test::bar();
foo(t1);
int i=t3;
Test::Widget wg=t3;
}
system(“pause”);
return 0;
}

在默认为__PRETTY_FUNCTION__的输出是:
_private::Test::Test()
_private::Test::Test(int, …)
_private::Test::Test(T) [with T = double]
static void _private::Test::bar()
void _private::foo(_private::TestBase&)
_private::Test::operator T() const [with T = int]
_private::Test::operator T() const [with T = _private::Test::Widget]
virtual _private::Test::~Test()
virtual _private::Test::~Test()
virtual _private::Test::~Test()
Press any key to continue . . .
在GCC里的基本格式是:
(static or virtual)namespace::class::function(const or volatile), 而且对template还有附加描述, 但可惜没有对调用规范的描述.

第二个问题是”它是否能用于构造函数的初始化列表?”
为什么会这样问呢? 因为据标准说它只是函数体内隐式的定义. 即:
struct A{
A():pstr(str){  // err
static const char str[]=”hello”;
}
const char* pstr;
};
但这样是错的, 在初始化列表里的str会被认为是还没声明的. 但我用__func__
却没有报错.
struct A{
A():pstr(__func__){  // ok
static const char str[]=”hello”;
}
const char* pstr;
};

嗯, 看来它是先于函数体的.(我只用GCC试我还没肯定这个行为是否正确), 因为这个不确定所以我想了第三个问题”它是否能用于默认参数?”.

简单的代码试验说明这是不能的:
void foo(char const* pstr=__func__); // err
再试试
void foo(char const* pstr=__FUNCTION__); // ok
竟然编绎通过了, 但pstr==””. (看来这是__func__和__FUNCTION__的区别了)
看来它不是能作默认参数的了.

嗯, 真的吗?是否会有特例呢? 于是有想了Local Class的情况:

void foo(){
__func__;  // 必须在bar的定义前先显式用一次__func__

struct A{
void bar(char const* pstr=__func__){ // ok
puts(pstr);
}
};

A a;
a.bar();   // 输出的是”foo”而不是”bar”
}

对于第四个问题我没想到太好的例子, 大概只想到两个:
(base64的编码表)
char
ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789(int i){
if(i==62)return ‘+’;
if(i==63)return ‘/’;
return __func__[i];
}

char
(*EnBase64Tab)(int)=&ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789;
(COMMAND解释事例)
class Command{
virtual void do_execute()=0;
public:
static void Execute(const char* script[]){
/*
foreach(vec)
if(script[i]==vec.iter)
*iter.do_execute();
*/
}
protected:
static  CMDVEC vec;
};

CMDVEC Command::vec;

class Edit: public Command{
virtual void do_execute(){}
static Edit edit;
Edit(){Command::vec.push_back(std::make_pair(__func__, this));}
};
Edit Edit::edit;

class Search: public Command{
virtual void do_execute(){}
static Search search;
Search(){Command::vec.push_back(std::make_pair(__func__, this));}
};
Search Search::search;

就是说若你的应用中函数和它的名子有很大关联的时候可以用上它.

第五个问题是用那个比较好?
我查了一下网上的资料俱称__FUNCTION__只是__func__的一个宏. 但我实际在GCC的预处理器上试过并不是这样. 嗯我油印得一般情况下应该用__func__, 因为它比较短. 而且它是标准里指定的.

对于这个新特性我个人理解基本上是这样了, 还需要注意的是在不支持新特性的编绎器上不要用__func__作为变量名, 即使你认为不会用任何新行性, 也应该注意这点.