Структурированные привязки для вашего собственного типа, который не является структурой или кортежем (через общедоступную функцию-член)

Исправление ошибок в примере Саттера

Я думаю, что это опечатка/глюк в сообщении в блоге Херба Саттера: он должен был сделать этих членов общедоступными, или предоставить для них геттеры, или сделать функцию std::get() другом.

Кроме того, похоже, что Херб забыл поставить "x" в сигнатуре функции...

Объяснение функции get

Функция, которую вы цитируете, аналогична тому, как std::get() работает для кортежей. Если у меня есть

std::tuple<int, std::string> t;

тогда

auto x { std::get<0>(t) }; // x is an integer
auto y { std::get<1>(t) }; // y is an std::string

и в примере Херба ему нужно иметь ту же работу для класса S, т.е. чтобы std::get<0>(s) возвращал первый элемент класса s, std::get<1>(s) возвращал второй элемент и т. д. Это необходимо, потому что иначе вы не можете использовать S для инициализации класса. структурированное связывание.

«Магия» в реализации Hebr заключается в том, что он возвращает значения разных типов из разных точек своей функции. Эта «магия» — эффект if constexpr. По сути, это означает, что компилятор игнорирует все, кроме синтаксиса нерелевантных ветвей. Итак, для I = 0 функция такова:

auto get(const S&) {
  if (true) return x.i;
  /* else if constexpr(I == 1) return string_view{x.c}; 
     else if constexpr(I == 2) return x.d;
   */
}

для I = 1 это

template<int I>
auto get(const S&) {
   if      (false) {/* return x.i; */ ; }
   else if (true) return string_view{x.c};
   /* else if constexpr(I == 2) return x.d; */
   }
}

и т.д. И auto выбирает соответствующий тип.

Здесь много проблем.

Во-первых, чтобы претендовать на структурированные привязки, вам необходимо специализироваться tuple_size:

namespace std {
    template <> struct tuple_size<foobar> : std::integral_constant<size_t, 2> { };
}

Далее, ваши специализации tuple_element также должны быть в namespace std:

namespace std {
    template <> struct tuple_size<foobar> : std::integral_constant<size_t, 2> { };

    template <> struct tuple_element<0,foobar> { using type = int; };
    template <> struct tuple_element<1,foobar> { using type = std::string; };
}

Затем ваша get должна быть объявлена ​​как функция friend, если вы собираетесь получить доступ к закрытым членам, как обычно:

class foobar {
    template <int I> friend auto get(foobar const& );
};

Наконец, get() действительно имеет лучшие возвращаемые ссылки, иначе ваши привязки в конечном итоге будут делать удивительные вещи:

template<int I>
auto const& get(const foobar&x) {
    if      constexpr(I == 0) return x._ival;
    else if constexpr(I == 1) return x.s;
}

Вместо того, чтобы иметь дело с friendship, проще просто сделать get() общедоступным членом, а затем написать три необходимых перегрузки:

class foobar {
public:
    template <size_t I>
    auto& get() & {
        if constexpr (I == 0) return _ival;
        else if constexpr (I == 1) return s;
    }

    template <size_t I>
    auto const& get() const& {
        if constexpr (I == 0) return _ival;
        else if constexpr (I == 1) return s;
    }

    template <size_t I>
    auto&& get() && {
        if constexpr (I == 0) return std::move(_ival);
        else if constexpr (I == 1) return std::move(s);
    }
};

Также ival() как функция не имеет смысла. Ваш конструктор должен просто принимать аргументы.