如何查明这个预处理器宏是否存在？

发布于 2024-09-29 02:37:55 字数 651 浏览 1 评论 0原文

我想知道如何确定预处理器宏 __PRETTY_FUNCTION__ 是否可以与给定的编译器一起使用（因为它应该是非标准的）。如何在头文件中检查这一点？我想做的是这样的：

#ifndef __PRETTY_FUNCTION__
   #define __PRETTY_FUNCTION__ __func__
#endif

但是，我猜发生的情况是预处理器为每个函数定义了宏，所以我想知道 __PRETTY_FUNCTION__ 是否有任何意义（与 __FILE__ 不同） 或 __LINE__) 在函数外部。这是真的还是我可以使用上面的代码？如果没有，我该如何检查？

编辑：我试过了。 __PRETTY_FUNCTION__ 在函数外部未定义（我没有在类内部检查）。所以必须有另一种方式。

EDIT2：实际上一个简单的黑客就是这样做:)：

void Dummy()
{
    #ifndef __PRETTY_FUNCTION__
       #define __PRETTY_FUNCTION__ __func__
    #endif
}

另一种方法是按照其他人的建议检查编译器。

原文

I want to know how to find out if the preprocessor macro __PRETTY_FUNCTION__ can be used with a given compiler (As it is supposed to be non-standard). How do I check this in a header file? What I want to do is something like:

#ifndef __PRETTY_FUNCTION__
   #define __PRETTY_FUNCTION__ __func__
#endif

But, I'm guessing what happens is the preprocessor defines the macro in place for each function so I wonder whether there's any meaning to __PRETTY_FUNCTION__ (Unlike __FILE__ or __LINE__) outside a function. Is this true or can I just use the code above? If not, how do I check for it?

EDIT: I tried it. __PRETTY_FUNCTION__ is undefined outside a function (I didn't check inside a class). So there has to be another way.

EDIT2: Actually a simple hack would be to do this :):

void Dummy()
{
    #ifndef __PRETTY_FUNCTION__
       #define __PRETTY_FUNCTION__ __func__
    #endif
}

The other method is to check for compiler as was suggested by others.

分享到QQ

分享到微博

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

发布评论

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

若有似无的小暗淡 2024-10-06 02:37:55

您可能必须知道您正在使用哪个编译器。对于 GCC（GNU 编译器集合），您可能会测试：

#ifdef __GNUG__
...use __PRETTY_FUNCTION__
#endif

如果您知道哪个编译器引入了该功能，并且您的代码面临使用旧版本编译的危险，则可以检查编译器版本。

GCC（4.4.1）手册说：

在 C 语言中，__PRETTY_FUNCTION__ 是 __func__ 的另一个名称。然而，在 C++ 中，__PRETTY_FUNCTION__ 包含函数的类型签名及其裸名称。
例如这个程序：
<前><代码> extern "C" {
extern int printf(char *, ...);
}
A类{
民众：
无效子（int i）
{
printf ("__FUNCTION__ = %s\n", __FUNCTION__);
printf ("__PRETTY_FUNCTION__ = %s\n", __PRETTY_FUNCTION__);
}
};
整数
主要（空）
{
一把斧头；
ax.sub(0);
返回0；
}
给出这个输出：
<前><代码> __FUNCTION__ = 子
__PRETTY_FUNCTION__ = void a::sub(int)
这些标识符不是预处理器宏。在 GCC 3.3 及更早版本中，仅在 C 中，__FUNCTION__ 和 __PRETTY_FUNCTION__ 被视为字符串文字；它们可以被使用
初始化 char 数组，并且它们可以与其他字符串文字连接。海湾合作委员会
3.4 及更高版本将它们视为变量，例如 __func__。在 C++ 中，__FUNCTION__ 和 __PRETTY_ FUNCTION__ 一直是变量。

You probably have to know which compiler you're using. For GCC (the GNU Compiler Collection), you'd probably test:

#ifdef __GNUG__
...use __PRETTY_FUNCTION__
#endif

You might check the compiler version if you know which one introduced the feature and you are in any danger of having your code compiled with an older version.

The GCC (4.4.1) manual says:

In C, __PRETTY_FUNCTION__ is yet another name for __func__. However, in C++, __PRETTY_FUNCTION__ contains the type signature of the function as well as its bare name.
For example, this program:
 extern "C" {
     extern int printf (char *, ...);
 }
 class a {
 public:
     void sub (int i)
     {
         printf ("__FUNCTION__ = %s\n", __FUNCTION__);
         printf ("__PRETTY_FUNCTION__ = %s\n", __PRETTY_FUNCTION__);
     }
 };
 int
 main (void)
 {
     a ax;
     ax.sub (0);
     return 0;
 }
gives this output:
 __FUNCTION__ = sub
 __PRETTY_FUNCTION__ = void a::sub(int)
These identifiers are not preprocessor macros. In GCC 3.3 and earlier, in C only, __FUNCTION__ and __PRETTY_FUNCTION__ were treated as string literals; they could be used
to initialize char arrays, and they could be concatenated with other string literals. GCC
3.4 and later treat them as variables, like __func__. In C++, __FUNCTION__ and __PRETTY_ FUNCTION__ have always been variables.