可以使用模板按名称访问struct变量吗？

Question

我们假设我有一个这样的结构:

struct my_struct
{
  int a;
  int b; 
}

我有一个函数应该为"a"或"b"设置一个新值.此函数还需要指定要设置的变量.一个典型的例子是这样的:

void f(int which, my_struct* s, int new_value)
{
  if(which == 0)
     s->a = new_value;
  else
     s->b = new_value; 
}

由于我不会在这里写的原因,我无法将指针传递给a/b到f.所以我不能用my_struct :: a或my_struct :: b的地址调用f.我不能做的另一件事是在my_struct中声明一个向量(int vars [2])并将一个整数作为索引传递给f.基本上在f中我需要按名称访问变量.

以前的例子的问题是,在将来我计划向struct添加更多变量,在这种情况下,我将记得向f添加更多if语句,这对于可移植性是不利的.我能做的就是将f写为宏,如下所示:

#define FUNC(which)
void f(my_struct* s, int new_value) \
{ \
        s->which = new_value; \
} 

然后我可以调用FUNC(a)或FUNC(b).

这可行,但我不喜欢使用宏.所以我的问题是:有没有办法使用模板而不是宏来实现相同的目标？

编辑:我将尝试解释为什么我不能使用指针,我需要按名称访问变量.基本上,结构包含系统的状态.该系统需要在请求时"撤消"其状态.使用名为undo_token的接口处理撤消,如下所示:

class undo_token
{
public:
   void undo(my_struct* s) = 0;
};

因此,由于多态性,我无法将指针传递给undo方法(mystruct也包含其他类型的变量).

当我向结构中添加一个新变量时,我通常还会添加一个新类,如下所示:

class undo_a : public undo_token
{
  int new_value;
public:
  undo_a(int new_value) { this->new_value = new_value; }
  void undo(my_struct *s) { s->a = new_value}
};

问题是当我创建令牌时我不知道指向s的指针,因此我无法在构造函数中保存指向s :: a的指针(这将解决问题)."b"的类是相同的,只需要写"s-> b"而不是s-> a

也许这是一个设计问题:我需要每个变量类型的撤销令牌,而不是每个变量一个...

Answer 1

要回答确切的问题,有,但它非常复杂,它纯粹是编译时的事情.(如果您需要运行时查找,请使用指向成员的指针 - 并且根据您更新的问题,您可能误解了它们的工作方式.)

首先,您需要一些可以在编译时用来表示"成员名称"的东西.在编译时元编程中,除了整数之外的所有东西都必须用类型来表示.所以你将使用一种类型来表示一个成员.

例如,存储一个人年龄的整数类型的成员,以及存储其姓氏的另一个成员:

struct age { typedef int value_type; };
struct last_name { typedef std::string value_type; };

然后你需要像map编译时那样查找的东西.我们叫它吧ctmap.让我们支持最多8名成员.首先,我们需要一个占位符来表示字段的缺失:

struct none { struct value_type {}; };

然后我们可以向前声明形状ctmap:

template <
    class T0 = none, class T1 = none,
    class T2 = none, class T3 = none,
    class T4 = none, class T5 = none,
    class T6 = none, class T7 = none
    >
struct ctmap;

然后我们专门针对没有字段的情况:

template <>
struct ctmap<
    none, none, none, none,
    none, none, none, none
    >
{
    void operator[](const int &) {};
};

其原因很快就会明白(可能).最后,所有其他案例的定义:

template <
    class T0, class T1, class T2, class T3,
    class T4, class T5, class T6, class T7
    >
    struct ctmap : public ctmap<T1, T2, T3, T4, T5, T6, T7, none>
    {
        typedef ctmap<T1, T2, T3, T4, T5, T6, T7, none> base_type;

        using base_type::operator[];
        typename T0::value_type storage;

        typename T0::value_type &operator[](const T0 &c)
        { return storage; }
};

这到底是怎么回事？如果你把:

ctmap<last_name, age> person;

C++将person通过递归扩展模板来构建一个类型,因为它ctmap 继承自身,我们为第一个字段提供存储,然后在继承时丢弃它.当没有更多的领域时,这一切都会突然停止,因为所有人都可以参加比赛none.

所以我们可以说:

person[last_name()] = "Smith";
person[age()] = 104;

这就像在a中查找map,但在编译时,使用字段命名类作为键.

这意味着我们也可以这样做:

template <class TMember>
void print_member(ctmap<last_name, age> &person)
{
    std::cout << person[TMember()] << std::endl;
}

这是一个打印一个成员值的函数,其中要打印的成员是一个类型参数.所以我们可以这样称呼它:

print_member<age>(person);

所以是的,你可以编写struct一个有点像编译时的东西map.

Answer 2

#include <iostream>
#include <ostream>
#include <string>

struct my_struct
{
    int a;
    std::string b;
};

template <typename TObject, typename TMember, typename TValue>
void set( TObject* object, TMember member, TValue value )
{
    ( *object ).*member = value;
}

class undo_token {};

template <class TValue>
class undo_member : public undo_token
{
    TValue new_value_;
    typedef TValue my_struct::* TMember;
    TMember member_;

public:
    undo_member(TMember member, TValue new_value):
        new_value_( new_value ),
        member_( member )
    {}

    void undo(my_struct *s) 
    { 
        set( s, member_, new_value_ );
    }
};    

int main()
{
    my_struct s;

    set( &s, &my_struct::a, 2 );
    set( &s, &my_struct::b, "hello" );

    std::cout << "s.a = " << s.a << std::endl;
    std::cout << "s.b = " << s.b << std::endl;

    undo_member<int> um1( &my_struct::a, 4 );
    um1.undo( &s );

    std::cout << "s.a = " << s.a << std::endl;

    undo_member<std::string> um2( &my_struct::b, "goodbye" );
    um2.undo( &s );

    std::cout << "s.b = " << s.b << std::endl;

    return 0;
}

Answer 3

除了Daniel Earwicker的回答之外,我们可以在新的C++标准中使用可变参数模板来实现相同的目标.

template <typename T>
struct Field {
  typename T::value_type storage;

  typename T::value_type &operator[](const T &c) {
    return storage;
  }
};

template<typename... Fields>
struct ctmap : public Field<Fields>... {
};

此代码更清晰,没有固定的成员范围.您可以以相同的方式使用它

struct age { typedef int value_type; };
struct last_name { typedef std::string value_type; };

ctmap<last_name, age> person;

person[last_name()] = "Smith";
person[age()] = 104;

Answer 4

Mykola Golubyev的答案很好,但是通过使用指向成员的指针可以用作非类型模板参数的事实可以略微改进:

#include <iostream>
#include <ostream>
#include <string>

struct my_struct
{
    int a;
    std::string b;
};

template <typename TObject, typename TMember, typename TValue>
void set( TObject* object, TMember member, TValue value )
{
    ( *object ).*member = value;
}

class undo_token {};

template <class TValue, TValue my_struct::* Member>
class undo_member : public undo_token
{
        // No longer need to store the pointer-to-member
        TValue new_value_;

public:
        undo_member(TValue new_value):
                new_value_(new_value)
        {}

        void undo(my_struct *s) 
        { 
                set( s, Member, new_value_ );
        }
};    

int main()
{
    my_struct s;

    set( &s, &my_struct::a, 2 );
    set( &s, &my_struct::b, "hello" );

    std::cout << "s.a = " << s.a << std::endl;
    std::cout << "s.b = " << s.b << std::endl;

    undo_member<int, &my_struct::a> um1( 4 );
    um1.undo( &s );

    std::cout << "s.a = " << s.a << std::endl;

    undo_member<std::string, &my_struct::b> um2( "goodbye" );
    um2.undo( &s );

    std::cout << "s.b = " << s.b << std::endl;

    return 0;
}

这削减了每个实例的成员指针的成本undo_member.

Answer 5

我不知道为什么你不能使用指针，所以我不知道这是否合适，但看看C++: Pointer to class data member，它描述了一种将指针传递给 a 的数据成员的方法结构/类不直接指向成员，但稍后绑定到结构/类指针。（在海报编辑后添加的强调解释了为什么不能使用指针）

这样，您就不会传递指向成员的指针 - 相反，它更像是对象内的偏移量。