C ++ preprocessor：避免code成员变量列表的重复 [英] C++ preprocessor: avoid code repetition of member variable list

问题描述

我有多个类的每个与在构造函数初始化平凡不同的成员变量。下面是一个例子：

I have a multiple classes each with different member variables that are initialized trivially in a constructor. Here is an example:

struct Person
{
    Person(const char *name, int age)
        :
        name(name),
        age(age)
    {
    }
private:
    const char *name;
    int age;
};

每个都有一个相关的打印＆LT;方式＆gt;（）函数

Each has an associated print<>() function.

template <>
void print<Person>(const Person &person)
{
    std::cout << "name=" << name << "\n";
    std::cout << "age=" << age << "\n";
}

这code是容易出错，因为参数列表四个地方复制。我怎么可以重写code，以避免这种重复？我想用preprocessor和/或模板。

This code is error prone since the parameter list is replicated in four places. How can I rewrite the code to avoid this duplication? I'd like to use the preprocessor and/or templates.

例如，我可以使用X-ARGS preprocessor技术 - 像这样

For example, could I use the X-args preprocessor technique -- something like this?

#define ARGUMENTS \
    ARG(const char *, name) \
    ARG(int, age)

struct Person
{
    Person(LIST_TYPE_NAME_COMMA(ARGUMENTS))
       :
       LIST_NAME_INIT(ARGUMENTS)
    {
    }
private:
    LIST_TYPE_NAME_SEMICOLON(ARGUMENTS)
};

template <>
void print<Person>(const Person &person)
{
   LIST_COUT_LINE(ARGUMENTS)
}

#undef ARGUMENTS

或者更好的，基于模板的方法？

Or better, a template-based approach?

请不要质疑我为什么要这么做，还有理由是导致使用命名参数的多个类似物体的设计决策。该参数需要被命名为成员变量出于性能的考虑。我只是在探索是否有可能列出的参数和它们的类型只有一次。

Please don't question why I want to do this, there are reasoned design decisions that have resulted in multiple similar objects with named parameters. The parameters need to be named member variables for performance reasons. I'm just exploring whether it's possible to list the parameters and their types only once.

推荐答案

您需要做的是有preprocessor生成有关领域的反射数据。这个数据可被存储为嵌套类。

What you need to do is have the preprocessor generate reflection data about the fields. This data can be stored as nested classes.

首先，使其更容易和更清洁的把它写在我们将使用类型前pression的preprocessor。类型化的前pression只是一个前pression是把类型在括号中。因此，而不是写 INT X 你会写（INT）X 。这里有一些方便的宏以帮助键入的前pressions：

First, to make it easier and cleaner to write it in the preprocessor we will use typed expression. A typed expression is just an expression that puts the type in parenthesis. So instead of writing int x you will write (int) x. Here are some handy macros to help with typed expressions:

#define REM(...) __VA_ARGS__
#define EAT(...)

// Retrieve the type
#define TYPEOF(x) DETAIL_TYPEOF(DETAIL_TYPEOF_PROBE x,)
#define DETAIL_TYPEOF(...) DETAIL_TYPEOF_HEAD(__VA_ARGS__)
#define DETAIL_TYPEOF_HEAD(x, ...) REM x
#define DETAIL_TYPEOF_PROBE(...) (__VA_ARGS__),
// Strip off the type
#define STRIP(x) EAT x
// Show the type without parenthesis
#define PAIR(x) REM x

接下来，我们定义一个 REFLECTABLE 宏以生成关于每个字段（加字段本身）中的数据。这个宏将被称为是这样的：

Next, we define a REFLECTABLE macro to generate the data about each field(plus the field itself). This macro will be called like this:

REFLECTABLE
(
    (const char *) name,
    (int) age
)

因此​​，使用 Boost.PP 我们遍历每个参数并产生这样的数据：

So using Boost.PP we iterate over each argument and generate the data like this:

// A helper metafunction for adding const to a type
template<class M, class T>
struct make_const
{
    typedef T type;
};

template<class M, class T>
struct make_const<const M, T>
{
    typedef typename boost::add_const<T>::type type;
};


#define REFLECTABLE(...) \
static const int fields_n = BOOST_PP_VARIADIC_SIZE(__VA_ARGS__); \
friend struct reflector; \
template<int N, class Self> \
struct field_data {}; \
BOOST_PP_SEQ_FOR_EACH_I(REFLECT_EACH, data, BOOST_PP_VARIADIC_TO_SEQ(__VA_ARGS__))

#define REFLECT_EACH(r, data, i, x) \
PAIR(x); \
template<class Self> \
struct field_data<i, Self> \
{ \
    Self & self; \
    field_data(Self & self) : self(self) {} \
    \
    typename make_const<Self, TYPEOF(x)>::type & get() \
    { \
        return self.STRIP(x); \
    }\
    typename boost::add_const<TYPEOF(x)>::type & get() const \
    { \
        return self.STRIP(x); \
    }\
    const char * name() const \
    {\
        return BOOST_PP_STRINGIZE(STRIP(x)); \
    } \
}; \

这样做是产生一个恒定 fields_n 是在类reflectable字段数。然后，它擅长的 field_data 为每个字段。它还朋友反射类，这是因此它甚至可以进入字段时，他们的私人

What this does is generate a constant fields_n that is number of reflectable fields in the class. Then it specializes the field_data for each field. It also friends the reflector class, this is so it can access the fields even when they are private:

struct reflector
{
    //Get field_data at index N
    template<int N, class T>
    static typename T::template field_data<N, T> get_field_data(T& x)
    {
        return typename T::template field_data<N, T>(x);
    }

    // Get the number of fields
    template<class T>
    struct fields
    {
        static const int n = T::fields_n;
    };
};

现在遍历，我们使用访问者模式的字段。我们创建一个从0 MPL范围字段的数目，并在该索引位置访问该字段的数据。然后将其传递到用户提供的访问者字段数据：

Now to iterate over the fields we use the visitor pattern. We create an MPL range from 0 to the number of fields, and access the field data at that index. Then it passes the field data on to the user-provided visitor:

struct field_visitor
{
    template<class C, class Visitor, class T>
    void operator()(C& c, Visitor v, T)
    {
        v(reflector::get_field_data<T::value>(c));
    }
};


template<class C, class Visitor>
void visit_each(C & c, Visitor v)
{
    typedef boost::mpl::range_c<int,0,reflector::fields<C>::n> range;
    boost::mpl::for_each<range>(boost::bind<void>(field_visitor(), boost::ref(c), v, _1));
}

现在的关键时刻，我们把它放在一起。下面是我们如何可以定义人类：

Now for the moment of truth we put it all together. Here is how we can define the Person class:

struct Person
{
    Person(const char *name, int age)
        :
        name(name),
        age(age)
    {
    }
private:
    REFLECTABLE
    (
        (const char *) name,
        (int) age
    )
};

下面是广义的 print_fields 功能：

struct print_visitor
{
    template<class FieldData>
    void operator()(FieldData f)
    {
        std::cout << f.name() << "=" << f.get() << std::endl;
    }
};

template<class T>
void print_fields(T & x)
{
    visit_each(x, print_visitor());
}

一个例子：

int main()
{
    Person p("Tom", 82);
    print_fields(p);
    return 0;
}

它输出：

name=Tom
age=82

和瞧，我们刚刚实现用C ++的反射，在100行code的。

And voila, we have just implemented reflection in C++, in under 100 lines of code.

这篇关于C ++ preprocessor：避免code成员变量列表的重复的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！