Hacer tipo personalizado " tie-able "(compatible con std:: tie)

Solo hay dos maneras de intentar ir:

1. Utilice los operadores de asignación de plantilla:
   Debe derivar públicamente de un tipo el operador de asignación con plantilla coincide exactamente.
2. Utilice los operadores de asignación no templados:
   Ofrezca una conversión no-explicit al tipo que espera el operador de copia no templada, por lo que se utilizará.
3. No hay una tercera opción.

En ambos casos, su tipo debe contener los elementos que desea asignar, de ninguna manera rodean.

#include <iostream>
#include <tuple>
using namespace std;

struct X : tuple<int,int> {
};

struct Y {
    int i;
    operator tuple<int&,int&>() {return tuple<int&,int&>{i,i};}
};

int main()
{
    int a, b;
    tie(a, b) = make_tuple(9,9);
    tie(a, b) = X{};
    tie(a, b) = Y{};
    cout << a << ' ' << b << '\n';
}

En coliru: http://coliru.stacked-crooked.com/a/315d4a43c62eec8d

Como las otras respuestas ya explican, o bien tiene que heredar de un tuple (para que coincida con la plantilla del operador de asignación) o convertir a la misma tuple de referencias (para que coincida con el operador de asignación no templada tomando un tuple de referencias del mismo tipo).

Si heredaras de una tupla, perderías los miembros nombrados, es decir, foo.a ya no es posible.

En esta respuesta, presento otra opción: Si estás dispuesto a pagar por un espacio overhead (constante por miembro) puede tener ambos miembros nombrados así como una herencia tupla simultáneamente heredando de una tupla de referencias const, es decir, un lazo const del objeto mismo: {[13]]}

struct Foo : tuple<const int&, const string&> {
    int a;
    string b;

    Foo(int a, string b) :
        tuple{std::tie(this->a, this->b)},
        a{a}, b{b}
    {}
};

Esta "atada" hace posible asignar un (non-const!) Foo a una vinculación de tipos de componentes convertibles. Dado que el "ated tie" es una tupla de referencias, asigna automáticamente los valores actuales de los miembros, aunque inicializado en el constructor.

¿Por qué la "corbata atada" const? Porque de lo contrario, un const Foo podría modificarse a través de su lazo adjunto.

Ejemplo de uso con tipos de componentes no exactos de la vinculación (tenga en cuenta el long long vs int):

int main()
{
    Foo foo(0, "bar");
    foo.a = 42;

    long long a;
    string b;

    tie(a, b) = foo;
    cout << a << ' ' << b << '\n';
}

Se imprimirá

42 bar

Demostración en Vivo

Así que esto resuelve los problemas 1. + 3. mediante la introducción de un espacio de arriba.

Este tipo de hace lo que quieres bien? (asume que sus valores se pueden vincular a los tipos de curso...)

#include <tuple>
#include <string>
#include <iostream>
#include <functional>
using namespace std;


struct Foo {
    int a;
    string b;

    template <template<typename ...Args> class tuple, typename ...Args>
    operator tuple<Args...>() const {
        return forward_as_tuple(get<Args>()...);
    }

    template <template<typename ...Args> class tuple, typename ...Args>
    operator tuple<Args...>() {
        return forward_as_tuple(get<Args>()...);
    }

    private:
    // This is hacky, may be there is a way to avoid it...
    template <typename T>
    T get()
    { static typename remove_reference<T>::type i; return i; }

    template <typename T>
    T get() const
    { static typename remove_reference<T>::type i; return i; }

};

template <>
int&
Foo::get()
{ return a; }

template <>
string&
Foo::get()
{ return b; }

template <>
int&
Foo::get() const
{ return *const_cast<int*>(&a); }

template <>
string&
Foo::get() const
{ return *const_cast<string*>(&b); }

int main() {
    Foo foo { 42, "bar" };
    const Foo foo2 { 43, "gah" };

    int a;
    string b;

    tie(a, b) = foo;
    cout << a << ", " << b << endl;

    tie(a, b) = foo2;
    cout << a << ", " << b << endl;

}

El mayor inconveniente es que solo se puede acceder a cada miembro por sus tipos, ahora, podría evitar esto con algún otro mecanismo (por ejemplo, definir un tipo por miembro y envolver la referencia al tipo por el tipo de miembro al que desea acceder..)

En segundo lugar, el operador de conversión no es explícito, se convertirá a cualquier tipo de tupla sé que no quieres eso..)

La principal ventaja es que no tiene que especificar explícitamente el tipo de conversión, todo se deduce...