5

我有一组用于实例化和初始化一组对象的方法。它们看起来都差不多，除了传递给Init函数的参数数量：

ObjectType* CreateObjectType(Arg1 a1, Arg2 arg2, ... ArgN aN)
{
    ObjectType* object = new ObjectType();
    [...]
    object->Init(this, a1, a2, ..., aN);
    [...]
    return object;
}

请注意，除了传递给Init函数外，不得在任何地方使用这些参数。

我想找到一种方法来实现所有这些，而不必为每种对象类型复制代码。

我尝试使用可变参数宏，结果如下（无效）：

#define CREATE_OBJECT_IMPL(ObjectType, ...)    \
ObjectType* Create##ObjectType##(__VA_ARGS__)  \
{                                              \
    ObjectType* object = new ObjectType();     \
    [...]
    object->Init(this, ##__VA_ARGS__);         \
    [...]
    return object;                             \
}

// This is the result I am trying to achieve :
CREATE_OBJECT_IMPL(MyFirstObject, bool, float)
CREATE_OBJECT_IMPL(MySecondObject, int)
CREATE_OBJECT_IMPL(MyThirdObject)

现在，在这个实现中，我使用了 VA_ARGS 两次，两次都错误：

  • 在第一种情况下，我想要一个具有我指定类型的参数列表（Arg1 a1，Arg2 a2...）

  • 在第二种情况下，我想通过它们的名称（ Init(a1, a2...) ）调用这些参数。

我尝试使用可变参数模板：

template< typename ObjectType, typename... Args >
ObjectType* CreateObject(Args args)
{
    ObjectType* object = new ObjectType();
    [...]
    object->Init(this, args);
    [...]
    return object;
}

#define CREATE_OBJECT_IMPL(ObjectType, ...)                     \
ObjectType* Create##ObjectType##(__VA_ARGS__)                   \
{                                                               \
    return CreateObject<ObjectType, __VA_ARGS__>(__VA_ARGS__);  \
}

...但这似乎也不起作用，我在模板定义行上收到以下错误：

错误 C2143：语法错误：在 '...' 之前缺少 ','

错误 C2065：“Args”：未声明的标识符

我正在使用VS2012。

我仍然可以为每个数量的参数编写 N 个类似的宏，但是我想知道是否有一种方法可以在不重复代码的情况下获得相同的结果？

4

2 回答 2

9

有几种方法可以解决这个问题。首先，您可以在宏中使用类型化表达式，以便解析类型。所以CREATE_OBJECT_IMPL会这样调用：

CREATE_OBJECT_IMPL(Object, (Arg1) arg1, (Arg2) arg2)

以下是一些将检索类型并剥离类型的宏：

#define EAT(x)
#define REM(x) x
#define STRIP(x) EAT x
#define PAIR(x) REM x

这些宏是这样工作的。当您编写STRIP((Arg1) arg1)时，它将扩展为arg1. 当你写PAIR((Arg1) arg1)它时，它会扩展为Arg1 arg1. 接下来，您要做的是将这些宏应用于传入的每个参数，所以这里有一个简单的APPLY宏，可以让您对最多 8 个参数执行此操作：

/* This counts the number of args */
#define NARGS_SEQ(_1,_2,_3,_4,_5,_6,_7,_8,N,...) N
#define NARGS(...) NARGS_SEQ(__VA_ARGS__, 8, 7, 6, 5, 4, 3, 2, 1)

/* This will let macros expand before concating them */
#define PRIMITIVE_CAT(x, y) x ## y
#define CAT(x, y) PRIMITIVE_CAT(x, y)

/* This will call a macro on each argument passed in */
#define APPLY(macro, ...) CAT(APPLY_, NARGS(__VA_ARGS__))(macro, __VA_ARGS__)
#define APPLY_1(m, x1) m(x1)
#define APPLY_2(m, x1, x2) m(x1), m(x2)
#define APPLY_3(m, x1, x2, x3) m(x1), m(x2), m(x3)
#define APPLY_4(m, x1, x2, x3, x4) m(x1), m(x2), m(x3), m(x4)
#define APPLY_5(m, x1, x2, x3, x4, x5) m(x1), m(x2), m(x3), m(x4), m(x5)
#define APPLY_6(m, x1, x2, x3, x4, x5, x6) m(x1), m(x2), m(x3), m(x4), m(x5), m(x6)
#define APPLY_7(m, x1, x2, x3, x4, x5, x6, x7) m(x1), m(x2), m(x3), m(x4), m(x5), m(x6), m(x7)
#define APPLY_8(m, x1, x2, x3, x4, x5, x6, x7, x8) m(x1), m(x2), m(x3), m(x4), m(x5), m(x6), m(x7), m(x8)

然后你可以CREATE_OBJECT_IMPL这样定义：

#define CREATE_OBJECT_IMPL(ObjectType, ...) \
ObjectType* Create##ObjectType(APPLY(PAIR, __VA_ARGS__))  \
{ \
    ObjectType* object = new ObjectType(); \
    [...] \
    object->Init(this, APPLY(STRIP, __VA_ARGS__)); \
    [...] \
    return object; \
}

当然，如果您在 Visual Studio 上使用这些宏，您可能需要一些解决方法。当然，更好的解决方案是编写一个模板化的函数。所以你会这样称呼你CreateObject：

ObjectType* obj = CreateObject<ObjectType>(arg1, arg2, arg3);

在 C++11 中，您可以像这样使用可变参数模板：

template< typename ObjectType, typename... Args >
ObjectType* CreateObject(Args... args)
{
    ObjectType* object = new ObjectType();
    [...]
    object->Init(this, args...);
    [...]
    return object;
}

但是如果你的编译器不支持可变参数模板，你可以使用Boost.PP生成最多 10 个参数的重载（或者更多，如果你需要的话）：

#define GENERATE_OBJS_EACH(z, n, data) \
template<class ObjectType, BOOST_PP_ENUM_PARAMS_Z(z, n, class Arg)> \
ObjectType* CreateObject(BOOST_PP_ENUM_BINARY_PARAMS_Z(z, n, Arg, arg))  \
{ \
    ObjectType* object = new ObjectType(); \
    [...] \
    object->Init(this, BOOST_PP_ENUM_PARAMS_Z(z, n, arg)); \
    [...] \
    return object; \
}
/* Generate CreateObject template for up to 10 arguments */
BOOST_PP_REPEAT_FROM_TO_1(1, 10, GENERATE_OBJS_EACH, ~)

编辑：以下是使上述宏在 msvc 中工作所需的解决方法：

/* This counts the number of args */
#define NARGS_SEQ(_1,_2,_3,_4,_5,_6,_7,_8,N,...) N
#define NARGS_MSVC_WORKAROUND(x) NARGS_SEQ x
#define NARGS(...) NARGS_MSVC_WORKAROUND((__VA_ARGS__, 8, 7, 6, 5, 4, 3, 2, 1))

/* This will let macros expand before concating them */
#define PRIMITIVE_CAT(x, y) x ## y
#define CAT_MSVC_WORKAROUND(x) PRIMITIVE_CAT x
#define CAT(x, y) CAT_MSVC_WORKAROUND((x, y))

/* This will call a macro on each argument passed in */
#define APPLY(macro, ...) APPLY_MSVC_WORKAROUND(CAT(APPLY_, NARGS(__VA_ARGS__)), (macro, __VA_ARGS__))
#define APPLY_MSVC_WORKAROUND(m, x) m x
...
于 2013-08-18T05:38:22.583 回答
0

您必须在两者之后加上Args... args ：

ObjectType* CreateObject(Args args)

和这里：

object->Init(this, args);

那么代码应该是：

template< typename ObjectType, typename... Args >
ObjectType* CreateObject(Args... args)
{
    ObjectType* object = new ObjectType();
    [...]
    object->Init(this, args...);
    [...]
    return object;
}

另一个问题是 Visual Studio 2012 不支持可变参数模板，但 12 月 '12 版本支持，请检查您是否拥有最新版本的编译器。

此外，您不需要可变参数宏来重新创建新函数，您可以像这样指定 ObjectType：

ObjectType* obj = CreateObject<ObjectType>(foo, 1, "hi");
于 2013-08-14T16:39:29.467 回答