Шаблоны могут привыкнуть к переменным структуры доступа по имени?

Для ответа на точный вопрос существует, но он является довольно сложным, и это просто будет вещь времени компиляции. (При необходимости в поиске во время выполнения используйте указатель на участника - и на основе обновленного вопроса, Вы, возможно, неправильно поняли, как они работают.)

Первый, Вам нужно что-то, что можно использовать для представления "имени участника" во время компиляции. В метапрограммировании времени компиляции все кроме целых чисел должно быть представлено типами. Таким образом, Вы будете использовать тип для представления участника.

, Например, член целого числа типа, которое хранит возраст человека и другого для хранения их фамилии:

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

Тогда Вам нужно что-то как map, который делает поиск во время компиляции. Позвольте нам, назвал его ctmap. Давайте окажем ему поддержку максимум 8 участникам. Во-первых нам нужен заполнитель для представления отсутствия поля:

struct none { struct value_type {}; };

Тогда мы можем передать - объявляют форму [1 111]:

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++ создаст тип для [1 112] путем рекурсивного расширения шаблонов, потому что ctmap наследовался себе , и мы обеспечиваем устройство хранения данных для первого поля и затем отбрасываем его, когда мы наследовались. Это все прибывает во внезапную остановку, когда больше нет полей, потому что специализация для все-none умирает.

, Таким образом, мы можем сказать:

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

Это похоже на поиск в map, но во время компиляции, с помощью полевого класса идентификатора в качестве ключа.

Это означает, что мы можем также сделать это:

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

Это - функция, которая печатает значение одного участника, где участник, который будет распечатан, является параметром типа. Таким образом, мы можем назвать его как это:

print_member<age>(person);

Так да, можно записать вещь, которая немного похожа struct, немного как время компиляции map.

Я не уверен, почему Вы не можете использовать указатель, таким образом, я не знаю, является ли это соответствующим, но взгляните на C++: Указатель на элемент данных класса , который описывает способ, которым можно передать указатель на элемент данных структуры/класса, которая не указывает непосредственно участнику, , но позже связывается с указателем структуры/класса . (акцент, добавленный после редактирования плаката, объясняющего, почему указатель не может использоваться)

Этот способ, которым Вы не передаете указатель на участника - вместо этого, он больше похож на смещение в объекте.

Ответ 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.

Из того, что Вы описали, я предполагаю, что у Вас нет способа переопределить структуру.

, Если бы Вы сделали, я предложил бы, чтобы Вы использовали Повышение. Fusion для описания структуры с названными шаблоном полями. См. ассоциативные кортежи для получения дополнительной информации об этом. Оба вида структур могли бы на самом деле быть совместимыми (та же организация в памяти), но я вполне уверен нет никакого способа получить такую гарантию из стандарта.

, Если бы Вы не делаете, можно создать дополнение к структуре, которая предоставила бы Вам доступ к полям тот же способ, которым делают ассоциативные кортежи. Но это может быть немного словесным.

РЕДАКТИРОВАНИЕ

Теперь довольно ясно, что можно определить структуры путем, Вы хотите. Таким образом, я определенно предлагаю, чтобы Вы использовали boost.fusion.

Вы не можете использовать шаблоны для решения этого, но почему использование структура в te первом месте? Это походит на идеальное использование для станд.:: карта, которая отобразила бы имена к значениям.

Я не могу думать о причине, почему у Вас не было бы всего под рукой при создании команды отмены. Что Вы хотите быть в состоянии отменить, Вы сделали. Таким образом, я полагаю, что можно использовать указатели на участников класса и даже указатели на поля конкретного экземпляра класса при создании команды отмены.

Вы правы в своем разделе EDIT. Это вопрос дизайна.

Это походит на то, что Вы ищете, назван" отражение ", и да это часто реализуется с некоторой комбинацией шаблонов и макросов. Предупредите, что отражательные решения являются часто грязными и раздражающими для работы с, таким образом, можно хотеть провести некоторое исследование в них перед дайвингом в код, чтобы узнать, ли это действительно , что Вы хотите.