Boost.Utility/IdentityType 1.0.0

Lorenzo Caminiti `<lorcaminiti@gmail.com>`

根据 Boost 软件许可证版本 1.0 分发（参见附带文件 LICENSE_1_0.txt 或副本位于 https://boost.ac.cn/LICENSE_1_0.txt）

动机
解决方案
模板
抽象类型
附录：使用
附录：实现
参考

此库允许将类型包装在圆括号中，以便它们可以始终作为宏参数传递。

动机

考虑以下宏，它声明一个名为 varn 的变量，其类型为指定的 type（另请参见 var_error.cpp）

#define VAR(type, n) type var ## n

VAR(int, 1);                    // OK.
VAR(std::map<int, char>, 2);    // Error.

第一次宏调用正确地声明了一个名为 var1 的 int 类型变量。但是，第二次宏调用失败，生成一个类似以下的预处理器错误：

error: macro "VAR" passed 3 arguments, but takes just 2

这是因为作为第一个宏参数传递的 std::map 类型包含一个未用圆括号 () 包装的逗号 ,。预处理器将该未包装的逗号解释为宏参数之间的分隔符，从而得出宏收到了总共三个（而不是两个）参数，顺序如下：

std::map<int
char>
2

请注意，与编译器不同，预处理器仅识别圆括号 ()。角度括号 <> 和方括号 [] 在解析宏参数时不会被预处理器识别。

解决方案

在某些情况下，可以通过完全避免将类型表达式传递给宏来解决此问题。例如，在上面的情况下，可以使用 typedef 来指定宏外部的类型表达式（另请参见 var.cpp）。

typedef std::map<int, char> map_type;
VAR(map_type, 3); // OK.

当这种情况不可能或不希望发生时（例如，参见下面的函数模板 f），此库头文件 boost/utility/identity_type.hpp 定义了一个宏 BOOST_IDENTITY_TYPE，该宏可用于解决此问题，同时将类型表达式保留为宏参数之一（另请参见 var.cpp）。

#include <boost/utility/identity_type.hpp>

VAR(BOOST_IDENTITY_TYPE((std::map<int, char>)), 4); // OK.

宏 BOOST_IDENTITY_TYPE 展开为一个表达式，该表达式（在编译时）求值为指定的类型。指定的类型永远不会被拆分成多个宏参数，因为它总是被一组额外的圆括号 () 包裹。事实上，必须使用两组圆括号：用于调用宏 BOOST_IDENTITY_TYPE(...) 的括号，加上用于包装传递给宏的类型的内部括号 BOOST_IDENTITY_TYPE((...))。

此宏适用于任何 C++03 编译器（并且不使用可变参数宏）。^[1] 作者最初使用 Cygwin 上的 GNU Compiler Collection (GCC) C++ 4.5.3（启用和禁用 C++11 功能 -std=c++0x）以及 Windows 7 上的 Microsoft Visual C++ (MSVC) 8.0 开发并测试了此库。有关支持的编译器和平台的信息，请参见库的回归测试结果。

模板

当在模板中使用此宏时，必须在其前面加上 typename。例如，让我们编写一个宏，它以指定的 type 声明一个名为 argn 的函数参数（另请参见 template.cpp）。

#define ARG(type, n) type arg ## n

template<typename T>
void f( // Prefix macro with `typename` in templates.
    ARG(typename BOOST_IDENTITY_TYPE((std::map<int, T>)), 1)
) {
    std::cout << arg1[0] << std::endl;
}

std::map<int, char> a;
a[0] = 'a';

f<char>(a); // OK...
// f(a);    // ... but error.

但是，请注意，在调用函数时必须手动指定模板参数 char，如 f<char>(a) 所示。事实上，当使用 BOOST_IDENTITY_TYPE 宏包装函数模板参数时，编译器将无法再从函数调用中自动推断模板参数，而 f(a) 会做到这一点。^[2]（此限制不适用于类模板，因为类模板参数必须始终显式指定。）换句话说，如果不使用 BOOST_IDENTITY_TYPE 宏，C++ 通常能够自动推断函数模板参数，如下所示：

template<typename T>
void g(
    std::map<int, T> arg1
) {
    std::cout << arg1[0] << std::endl;
}

g<char>(a); // OK...
g(a);       // ... and also OK.

抽象类型

在某些编译器（例如 GCC）上，对此类抽象类型（即具有一个或多个纯虚函数的类）使用此宏会生成编译器错误。这可以通过操作类型，添加和删除其引用来避免。

让我们编写一个宏，它对模板元编程 (TMP) 元函数执行静态断言（类似于 Boost.MPL 的 BOOST_MPL_ASSERT）。宏 BOOST_IDENTITY_TYPE 可用于将带有多个模板参数的元函数传递给断言宏（以便处理分隔模板参数的逗号）。在这种情况下，如果元函数是抽象类型，则需要通过添加和删除其引用来进行操作（另请参见 abstract.cpp）。

#define TMP_ASSERT(metafunction) \
    BOOST_STATIC_ASSERT(metafunction::value)

template<typename T, bool b>
struct abstract {
    static const bool value = b;
    virtual void f(T const& x) = 0;     // Pure virtual function.
};

TMP_ASSERT(
    boost::remove_reference<            // Add and remove
        BOOST_IDENTITY_TYPE((           // reference for
            boost::add_reference<       // abstract type.
                abstract<int, true>
            >::type
        ))
    >::type
);

附录：使用

宏 BOOST_IDENTITY_TYPE 可以用于调用用户定义的宏时（如前面的示例所示），或在实现用户定义的宏时（如下所示）。当在用户定义的宏的实现中使用 BOOST_IDENTITY_TYPE 时，宏的调用者必须指定额外的括号（另请参见 paren.cpp）。

#define TMP_ASSERT_PAREN(parenthesized_metafunction) \
    /* use `BOOST_IDENTITY_TYPE` in macro definition instead of invocation */ \
    BOOST_STATIC_ASSERT(BOOST_IDENTITY_TYPE(parenthesized_metafunction)::value)

#define TMP_ASSERT(metafunction) \
    BOOST_STATIC_ASSERT(metafunction::value)

// Specify only extra parenthesis `((...))`.
TMP_ASSERT_PAREN((boost::is_const<std::map<int, char> const>));

// Specify both the extra parenthesis `((...))` and `BOOST_IDENTITY_TYPE` macro.
TMP_ASSERT(BOOST_IDENTITY_TYPE((boost::is_const<std::map<int, char> const>)));

但是，请注意，即使宏参数不包含逗号，调用者也总是必须指定额外的括号。

TMP_ASSERT_PAREN((boost::is_const<int const>)); // Always extra `((...))`.

TMP_ASSERT(boost::is_const<int const>); // No extra `((...))` and no macro.

在某些情况下，在用户定义的宏的实现中使用 BOOST_IDENTITY_TYPE 可能会为调用者提供最佳的语法。例如，BOOST_MPL_ASSERT 就是这种情况，因为大多数模板元编程表达式都包含未包装的逗号，所以让用户始终指定额外的括号 ((...)) 而不是使用 BOOST_IDENTITY_TYPE 混淆性更小。

BOOST_MPL_ASSERT(( // Natural syntax.
    boost::mpl::and_<
          boost::is_const<T>
        , boost::is_reference<T>
    >
));

然而，在其他情况下，最好不要在常见情况下要求额外的括号，而是使用 BOOST_IDENTITY_TYPE 将逗号作为特殊情况处理。例如，BOOST_LOCAL_FUNCTION 就是这种情况，在其中始终要求在类型周围使用额外的括号 ((...)) 会导致局部函数签名的语法不自然。

int BOOST_LOCAL_FUNCTION( ((int&)) x, ((int&)) y ) { // Unnatural syntax.
    return x + y;
} BOOST_LOCAL_FUNCTION_NAME(add)

相反，要求用户仅在需要时指定 BOOST_IDENTITY_TYPE，可以实现更自然的语法，例如 BOOST_LOCAL_FUNCTION(int& x, int& y)，在参数类型不包含逗号的常见情况下（同时仍然允许使用 BOOST_LOCAL_FUNCTION(BOOST_IDENTITY_TYPE((std::map<int, char>))& x, int& y) 作为特殊情况指定带有逗号的参数类型）。

附录：实现

此库宏的实现等效于：^[3]

#include <boost/type_traits/function_traits.hpp>

#define BOOST_IDENTITY_TYPE(parenthesized_type) \
    boost::function_traits<void parenthesized_type>::arg1_type

本质上，类型被包装在圆括号中 (std::map<int, char>)，因此即使它包含逗号，它也可以作为单个宏参数传递。然后，将带括号的类型转换为返回 void 并且第一个也是唯一的参数类型为指定类型的函数的类型 void (std::map<int, char>)。最后，使用 function_traits 元函数在编译时提取第一个参数的类型 arg1_type，从而从带括号的类型中获得原始类型（有效地剥离了指定类型周围的额外括号）。

参考

头文件 <boost/utility/identity_type.hpp>

将类型表达式包装在圆括号中，以便即使它们包含逗号也可以传递给宏。

BOOST_IDENTITY_TYPE(parenthesized_type)

宏 BOOST_IDENTITY_TYPE

BOOST_IDENTITY_TYPE — 此宏允许将指定的类型表达式包装在额外的圆括号中，以便即使类型包含逗号（未包装在圆括号中），也可以将其作为单个宏参数传递。

提要

// In header: <boost/utility/identity_type.hpp>

BOOST_IDENTITY_TYPE(parenthesized_type)

描述

参数

parenthesized_type 要作为宏参数传递的类型表达式，用一组圆括号 (...) 包裹。此类型表达式可以包含任意数量的逗号。

此宏适用于任何 C++03 编译器（它不使用可变参数宏）。

在模板中使用此宏时，必须在其前面加上 typename。请注意，当使用此宏包装函数模板参数时，编译器将无法自动确定函数模板参数（这些参数需要在调用函数模板时显式指定）。

在某些编译器（如 GCC）上，对此类抽象类型使用此宏需要添加和删除指定类型的引用。

^[1] 使用可变参数宏，可以要求一组额外的括号 BOOST_IDENTITY_TYPE(type) 而不是两组 BOOST_IDENTITY_TYPE((type))，但可变参数宏不是 C++03 的一部分（尽管如今它们被大多数现代编译器支持，并且它们也是 C++11 的一部分）。

^[2] 这是因为 BOOST_IDENTITY_TYPE 的实现将指定的类型包装在元函数中。

^[3] 宏是否实际上是使用此文档中列出的代码实现的，这完全没有保证。所列代码仅用于解释目的。

Boost C++ 库