Сделайте настраиваемый тип "связанный" (совместимый с std:: tie)

Ответ 1

Почему текущие попытки не срабатывают

std::tie(a, b) создает a std::tuple<int&, string&>. Этот тип не связан с std::tuple<int, string> и т.д.

std::tuple<T...> имеют несколько операторов присваивания:

• Оператор присваивания по умолчанию, который принимает std::tuple<T...>
• Преобразование шаблона-оператор-преобразование кортежа с пакетом параметров типа U..., который принимает std::tuple<U...>
• Пара-преобразование шаблона присваивания-оператора с двумя параметрами типа U1, U2, который принимает std::pair<U1, U2>

Для этих трех версий существуют варианты копирования и перемещения; добавьте либо теги const&, либо && к типам, которые они принимают.

Шаблоны-операторы-назначения должны вывести свои аргументы шаблона из типа аргумента функции (т.е. типа RHS выражения-назначения).

Без оператора преобразования в Foo ни один из этих операторов присваивания не является жизнеспособным для std::tie(a,b) = foo. Если вы добавите оператор преобразования в Foo, то становится доступным только оператор присваивания по умолчанию: Вычисление типа шаблона не учитывает пользовательские преобразования. То есть вы не можете вывести аргументы шаблона для шаблонов присваивания-оператора из типа Foo.

Поскольку только одно пользовательское преобразование допускается в неявной последовательности преобразований, тип, который преобразует оператор преобразования, должен точно соответствовать типу оператора присваивания по умолчанию. То есть он должен использовать те же самые типы элементов кортежа, что и результат std::tie.

Чтобы поддерживать преобразования типов элементов (например, назначение Foo::a в long), оператор преобразования Foo должен быть шаблоном:

struct Foo {
    int a;
    string b;
    template<typename T, typename U>
    operator std::tuple<T, U>();
};

Однако типы элементов std::tie являются ссылками. Поскольку вы не должны возвращать ссылку на временную, варианты конверсий внутри шаблона оператора довольно ограничены (куча, тип punning, статический, локальный поток и т.д.).

Ответ 2

Есть только два способа, которыми вы можете попробовать:

• Использование шаблонных операторов присваивания:
  Вам нужно публично выводить из типа, который точно соответствует шаблону присваивания-оператора.
• Использовать нестандартные операторы присваивания:
  Предложите преобразование не explicit в тип, который ожидает не-шаблонный оператор копирования, поэтому он будет использоваться.
• Третий вариант отсутствует.

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

#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';
}

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

Ответ 3

Как уже объясняют другие ответы, вам либо нужно наследовать от tuple (чтобы соответствовать шаблону оператора присваивания), либо преобразовать в тот же самый tuple ссылок (чтобы соответствовать не templated оператор присваивания, принимающий tuple ссылок одного и того же типа).

Если вы наследуете кортеж, вы потеряете именованные члены, т.е. foo.a больше не возможно.

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

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}
    {}
};

Эта "привязанная связь" позволяет назначить (не const!) Foo привязку типов конвертируемых компонентов. Так как "прикрепленная привязка" представляет собой набор ссылок, она автоматически присваивает текущие значения членам, хотя вы инициализировали его в конструкторе.

Почему "привязанный галстук" const? Поскольку в противном случае a const Foo можно было бы модифицировать с помощью прикрепленной привязки.

Пример использования с неточными составными типами привязки (обратите внимание на 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';
}

напечатает

42 bar

Живая демонстрация

Таким образом, это решает проблемы 1. + 3., введя пространственные служебные данные.

Ответ 4

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

#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;

}

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

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

Основное преимущество заключается в том, что вам не нужно явно указывать тип преобразования, все выведенное...