func 和 __PRETTY_FUNCTION__ 并非总是展开的

Question

func 和 __PRETTY_FUNCTION__ 并非总是展开的

3

我有一个日志库，它使用宏来跟踪消息。该宏利用预定义的宏，如

 __func__ 和 __PRETTY_FUNCTION__ ，以指示在哪个函数/方法中记录了消息。
我的日志库宏定义在日志库的主头文件中，不在任何函数之外。
由于某种原因，预处理的代码包含 __func__ （如果我正在使用这个宏，则是 __PRETTY_FUNCTION__ ），就像这些预定义的宏不存在一样。但我知道它们确实存在，因为如果我在不使用我的库的追踪宏的情况下使用它们，它们可以工作！
以下是我的库的宏：
#if _MSC_VER >= 1400 // If >= VS2005

    #define _TRACE_FUNC_SIGNATURE __FUNCSIG__

#elif defined(__ANDROID__) || defined( __GNUC__ ) && defined( __cplusplus ) // If G++ and/or Android NDK

    #define _TRACE_FUNC_SIGNATURE __func__

#else
    #error // Unsupported compiler
#endif

// Forces the reprocessing of x to properly expand __VA_ARGS__ when using MSVC compiler
#define _TRACE_REPROCESS( x ) x


#define _TRACE_X( _methodName_, _logCatPtr_, ... ) \
    do { \
        ::dbg::LogCategory * const _catPtrVal_ = (::dbg::LogCategory *)(_logCatPtr_); \
        if( NULL != _catPtrVal_ && _catPtrVal_->IsEnabled() ) \
        { \
            _TRACE_REPROCESS( _catPtrVal_->_methodName_( _TRACE_FUNC_SIGNATURE " - " __VA_ARGS__ ); ) \
        } \
    } while( false )


#define TRACE_E( _logCatPtr_, ... ) _TRACE_X( Error, _logCatPtr_, __VA_ARGS__ )
#define TRACE_W( _logCatPtr_, ... ) _TRACE_X( Warning, _logCatPtr_, __VA_ARGS__ )
#define TRACE_I( _logCatPtr_, ... ) _TRACE_X( Info, _logCatPtr_, __VA_ARGS__ )

我知道这些宏没有理由在函数外定义，但由于我只在函数/方法中使用我的跟踪宏，所以应该在那里定义！
我正在使用Eclipse提供的默认Android NDK编译器，据我所读，这是一种扩展的G++。
编辑：如果我用实际的字符串替换“__func__”，它可以工作，没有语法错误。这让我想到当我在宏中使用“__func__”时，它绝对没有被定义。

- Virus721

感谢您的评论。不幸的是，我得到了相同的结果。 - Virus721

我已经查看了预处理代码，其中包含 __func__ " - " ... 这会导致错误，因为变量不能像这样后跟一个字符串字面值。如果 __func__ 是一个宏，它将扩展为一个字符串字面值，编译器将把它前置到 " - "。 - Virus721

2个回答

1

我想加上我的一点建议-在预处理器指令中使用函数签名是可能的，但您必须先捕获它。以下是一个示例，逐步比较__PRETTY_FUNCTION__和预处理器替代方案。

#include <stdio.h>

#define CAT(X,Y) X ## Y

#define VAR(X) X
#define VAR_(X) VAR(X)

#define VAL(X) #X
#define VAL_(X) VAL(X)

/* Alias for constexpr cstring */
#define SZ const char*
#define CE_SZ constexpr SZ

/* Alias for assignment with appended log statement */
#define LOG(X, Y) X = Y; CE_SZ VAR_(CAT(INFO_, X)) = \
        VAL_(X) " = " VAL_(Y) " (" __FILE__ VAL_(:__LINE__) ")"

/* SZ_A has no preprocessor value */
CE_SZ SZ_A = "Value of SZ_A";

/* SZ_B only has value to the preprocessor during LOG
    (no define from inside a define, macro, etc.) */
CE_SZ LOG(SZ_B, "Value of SZ_B");

/* SZ_C has a global preprocessor name and value, but no compile time name */
#define SZ_C "Value of SZ_C"

/* SZ_D associates a compile time name with the value of SZ_C */
CE_SZ LOG(SZ_D, SZ_C);

/*
    __PRETTY_FUNCTION__ and __func__  don't expand to string literals, but
    to references to strings initialized by the compiler. If you capture the
    signature in a preprocessor define, it's available globally; if you pass
    it to a preprocessor macro, it's available within the scope of the macro.
    __PRETTY_FUNCTION__ depends on compiler implementation (if it's defined
    at all) - parameter names will be missing, template typenames and values
    will be enumerated, etc.
*/
#define SIG template<typename T = SZ> void test(T caller)
SIG {
    /* int main(int, const char**) */
    printf("  Called function: %s\n", caller);
    /* void test(T) [with T = const char*] */
    printf(" Current function: %s\n", __PRETTY_FUNCTION__);
    /* template<typename T = const char*> void test(T caller) */
    printf(" Preprocessor signature: " VAL_(SIG) "\n");
}

CE_SZ LOG(SZ_E, VAL_(SIG));

int main(int argc, const char *argv[]) {
    /* SZ_A = "Value of SZ_A" */
    printf("%s = \"%s\"\n", VAL_(SZ_A), SZ_A);

    /* SZ_B = "Value of SZ_B" (main.cpp:26) */
    printf("%s\n", INFO_SZ_B);

    /* SZ_C = "Value of SZ_C" */
    printf("%s\n", "SZ_C = " VAL_(SZ_C));

    /* SZ_D = "Value of SZ_D" (main.cpp:32) */
    printf("%s\n\n", INFO_SZ_D);

    test(__PRETTY_FUNCTION__);

    /* SZ_E = "template..." (main.cpp:53) */
    printf("\n%s\n", INFO_SZ_E);
}

- John P

网页内容由stack overflow 提供, 点击上面的

可以查看英文原文，
原文链接

- Sander De Dycker · Accepted Answer

在一些实现中，__func__是一个变量，而不是一个宏（至少在gcc中）。因此，您不能像使用字符串字面值一样使用它。

因此，这个代码：

_TRACE_REPROCESS( _catPtrVal_->_methodName_( _TRACE_FUNC_SIGNATURE " - " __VA_ARGS__ ); )

需要用不同的方式编写。我不知道 _catPtrVal_->_methodName_ 是如何实现的，但如果它可以接受多个参数，那么像这样的东西可能会起到作用：

_TRACE_REPROCESS( _catPtrVal_->_methodName_( _TRACE_FUNC_SIGNATURE, " - " __VA_ARGS__ ); )

如果不行，那么你将需要使用其他方式将 __func__ 与日志行的其余部分连接起来（例如使用 std::stringstream）。

更多细节：

C 标准将 __func__ 定义为：

标识符 __func__ 应被翻译器隐式声明，就好像在每个函数定义的左括号后面紧跟着声明：

static const char __func__[] = "function-name";

其中 function-name 是词法封闭函数的名称。

也就是说，它让实现决定是否将其提供为变量或宏（只要它的行为就像上面所示的定义一样）。

作为一个例子，gcc将其提供为变量，而MSVC将其提供为宏。

__func__ 和 __PRETTY_FUNCTION__ 并非总是展开的

func 和 __PRETTY_FUNCTION__ 并非总是展开的