template<class T> class reference
{
private:
  T* ptr_; // заодно избавимся от голой ссылки, ломающей модель Assignable на корню
public:
  reference(T& ref) : ptr_(&ref) {}

  T& get() { return *ptr_; }
  T const& get() const { return *ptr_; }

  // неявное приведение к T& / const T& - по вкусу.
  operator T&() { return get(); }
  operator T const&() const { return get(); }

  // присваивание пробрасывать или нет - определись сам. тут возможны варианты
  reference& operator = (reference const& src) { get() = src.get(); return *this; }

  // move-семантику - определись и продумай. тут возможны варианты
  reference(reference&& src);
  reference& operator = (reference&&);
  T&& get()&&;
  operator T&&()&&;
};

template<class T> struct pair
{
  const char* key;
  reference<T> value;
};

template<typename T>
struct pair {
   const char *key; // никогда не изменяется, назначается только при инициализации 'pair'
   const T     &val;
};

template<typename T>
void set(const pair<T> &pair) {
   // тут все хорошо, используем 'pair.key' и 'pair.val'
}
template<typename T>
void get(pair<T> &pair) {
   // тут все плохо, ибо 'pair.val' - константная ссылка
}

pair<int> pi{"int", 33};

set(pair<int>{"int", 33});
set(pi);

////////////////////////////////
get(pi); // читаем в 'pair<int>'
int rint=0;
get(pair<int>{"int", pint}); // читаем в 'pint' являющийся lvalue, 'pair<int>' же - rvalue

template<typename T>
pair<T> get()

template<typename Archive, typename... Args>
bool apply(Archive &ar, Args&&... args) {
   // тут 'Args...' - пак пар
   // тут в/из 'ar' записывается/считывается 'args...'
}

struct user_type {
   int i;
   long l;
   float f;

   // этот макрос генерит неоходиммый код для сериализации/десериализации
   YAS_SERIALIZE_ONE_MF(i, l, f);

   // развернется он в нечто типа:
   template<typename Archive>
   void serialize(Archive &ar) {
      apply(
          ar
         ,pair<decltype(i)>{"i", i}
         ,pair<decltype(l)>{"l", l}
         ,pair<decltype(f)>{"f", f}
      );
   }
};

#include <iostream>
#include <type_traits>

template<typename T>
void foo(T) { std::cout << __PRETTY_FUNCTION__ << std::endl; }

template<typename T>
struct pair {
    pair(T v)
        :key("")
        ,val(v)
    {}
    pair(const char *k, T v)
        :key(k)
        ,val(v)
    {}

    const char *key;
    T val;
};

template<typename T>
auto make_pair(const char *key, T &&val) {
        using R = typename std::conditional<
             std::is_rvalue_reference<decltype(val)>::value || std::is_const<decltype(val)>::value
            ,const T&
            ,T&
        >::type;
    return pair<R>{key, val};
}

int main() {
    int i=0;
    auto p0 = make_pair("i", 33);
    foo(p0);
    auto p1 = make_pair("i", i);
    foo(p1);

    foo(make_pair("i", 33));
    foo(make_pair("i", i));
}

template<typename Archive, typename... Args>
bool apply(Archive &ar, Args&&... args) {
   // тут 'Args...' - пак пар в раскрытом виде
}

struct user_type {
   int i;
   long l;
   float f;

   // этот макрос генерит необходиммый код для сериализации/десериализации
   YAS_SERIALIZE_ONE_MF(i, l, f);

   // развернется он в нечто типа:
   template<typename Archive>
   void serialize(Archive &ar) {
      apply(
          ar
          , "i", i
          , "l", l
          , "f", f
      );
   }
};

yas::mem_ostream os;
yas::binary_oarchive<yas::mem_ostream> oa(os);

struct usertype {};
usertype u;

// 1: one free function for read/write
template<typename Archive>
void serialize(Archive &ar, usertype &v) {
   ar & v;
}

// 2: separate free functions
template<typename Archive>
void serialize(Archive &ar, const usertype &v) { // write
   ar & v;
}
template<typename Archive>
void serialize(Archive &ar, usertype &v) { // read
   ar & v;
}

// 3: one member function for read/write
struct usertype2 {
   int a, b;

   template<typename Archive>
   void serialize(Archive &ar) {
      ar & a
         & b;
   }
};


// 4: separate member function for read/write
struct usertype3 {
   int a, b;

   template<typename Archive>
   void serialize(Archive &ar) const { // write
      ar & a
         & b;
   }
   template<typename Archive>
   void serialize(Archive &ar) { // read
      ar & a
         & b;
   }
};


// ну и такое недавно добавил по просьбам пользователей:

int a, b;
ar(a, b); // operator(...)
ar.serialize(a, b);

}

#include <iostream>

/**************************************************************************/

template<typename T>
void foo(T v) { std::cout << v.key << ": " << __PRETTY_FUNCTION__ << std::endl; }

template<typename T>
struct pair {
    pair(T v)
        :key("")
        ,val(v)
    {}
    pair(const char *k, T v)
        :key(k)
        ,val(v)
    {}

    const char *key;
    T val;
};

template<typename T>
auto make_pair(const char *key, T &val) {
    return pair<T &>{key, val};
}

template<typename T>
auto make_pair(const char *key, const T &val) {
    return pair<const T &>{key, val};
}

/**************************************************************************/

struct type {
    int a;
    int b;

    type()
        :a{}
        ,b{}
    {}

    void m0() const {
        const auto p0 = make_pair("type.a", a);
        foo(p0);
    }
    void m1() {
        const auto p0 = make_pair("type.b", b);
        foo(p0);
    }
};

/**************************************************************************/

int main() {
    type t;
    t.m0();
    t.m1();

    int c=0;
    const int d=0;
    auto p0 = make_pair("b", 33);
    foo(p0);
    auto p1 = make_pair("c", c);
    foo(p1);
    auto p2 = make_pair("d", d);
    foo(p2);

    std::cout << "**********************************" << std::endl;
    int f=0;
    const int g=0;
    foo(make_pair("i", 33));
    foo(make_pair("f", f));
    foo(make_pair("g", g));
}

/**************************************************************************/

struct type {
   template<typename Ar>
   void serialize(Ar &ar) const {} // save to ar
   void serialize(Ar &ar) {} // read from ar
};

X>struct type {
X>   template<typename Ar>
X>   void serialize(Ar &ar) const {} // save to ar
X>   void serialize(Ar &ar) {} // read from ar
X>};
X>

template<class Ar, class Pair, class... Pairs>
void do_serialize_all(Ar& ar, Pair&& p, Pairs...&& ps)
{
  do_serialize_one(ar, p);
  do_serialize_all(ar, ps...);
}

template<class Arr, class T>
void do_serialize_one(Ar& ar, std::tuple<const char*, T&>&& p)
{
  // поскольку одно из полей ссылочное, то распотрошить tuple, сопоставляя с tie, не получится.
  const char* key = std::get<0>(p);
  T& var = std::get<1>(p);
  ??????? // сериализуй как хочешь
}

strust YourType
{
  template<class Arr> void serialize(Ar& ar) const // можно только писать в архив
  {
    assert(serialize_mode_is_saving(ar));
    const_cast<YourType*>(this)->serialize(ar); // внаглую снимем константность, - сейчас это нестрашно
  }
  template<class Arr> void serialize(Ar& ar) // может быть и туда, и сюда!
  {
    // всю содержательную работу сделаем в этой ветке
    do_serialize_all(ar,
      std::tie("x",x),
      std::tie("y",y),
      std::tie("z",z)
    );
  }
};

class YourStruct
{
  template<class Myself, class Ar> // Myself = YourStruct (+const)
  friend do_serialize(Myself& myself, Ar& ar)
  {
    apply(ar, tie("x", myself.x), tie("y", myself.y), tie("z", myself.z));
  }

public:
  template<class Ar> void serialize(Ar& ar)       { do_serialize(*this, ar); } // load/save
  template<class Ar> void serialize(Ar& ar) const { do_serialize(*this, ar); } // save only
};