Наткнулся на такую ошибку компиляции в моём коде : https://stackoverflow.com/questions/51329748/type-deduction-in-switch-and-sfinae-gcc-vs-clang Какой компилятор прав по стандарту? Должен ли Sfinae в этом случае сработать?

ЗАЧЕМ?

в смысле "зачем" ?

в смысле "зачем" ?

https://godbolt.org/g/dkqBGf это гениально, я считаю

for (auto [x,y] : map) vs for (auto& [x,y] : map)

вроде за этим

http://coliru.stacked-crooked.com/a/a32fb9caeeef097b

for (auto [x,y] : map) vs for (auto& [x,y] : map)

https://godbolt.org/g/KugZ5B

x,y теже да

но если ты хочешь поменять Y y всех в мапе в цикле тебе нужен auto & [x,y]

но если ты хочешь поменять Y y всех в мапе в цикле тебе нужен auto & [x,y]

я хочу, чтобы у меня auto [x, y] были auto x, auto y А НЕ decltype(auto) x, decltype(auto) y

ну прости это разные конструкции языка

разные что

auto x,y и auto [x,y]

угу

ну прости это разные конструкции языка

что по-вашему выведет программа? #include <functional> #include <utility> template <typename... Args> auto proxy(Args&&... args) { return std::forward_as_tuple<Args...>(args...); } int f() { int x = 0; auto [y] = proxy(x); auto z = std::get<0>(proxy(x)); y = 1; z = 2; return x; }

что по-вашему выведет программа? #include <functional> #include <utility> template <typename... Args> auto proxy(Args&&... args) { return std::forward_as_tuple<Args...>(args...); } int f() { int x = 0; auto [y] = proxy(x); auto z = std::get<0>(proxy(x)); y = 1; z = 2; return x; }

@antoshkka ну вот серьезно, зачем делать так?

@antoshkka ну вот серьезно, зачем делать так?

И я удивляюсь, зачем так писать )

И я удивляюсь, зачем так писать )

Смотрите. Вот почему, почему в случае structure binding auto [x, y] соответствует decltype(auto)?

Что на земле вообще мешало при бинде auto [x, y] = std::tie(a, b); делать x и y значениями?

там используется tuple_element, а он в данном случае int&

да, но выражение auto z = std::get<0>(proxy(x));

а тут почему-то decltype(auto) y = std::get<0>(proxy(x));

при синтаксисе auto [y] = proxy(x)

да

а я так надеялся, что придет 17 стандарт и я наконец-то удалю две реализации zip и zip_view и буду писать auto [a, b] и auto & [a, b]

и это при том, что есть const auto& [y] = proxy(x);

давйте issue заведём на CWG но я очень сомневаюсь, что ситуация изменится

так это ломает пользовательский код

так что можно только задаваться вопросом "НУ ПОЧЕМУ"

Что на земле вообще мешало при бинде auto [x, y] = std::tie(a, b); делать x и y значениями?

Потому что declaration specifiers относятся к невидимой переменной которая справа от = Надо же как-то задавать хотим мы ее получать по ссылке или по значению. А для a, b уже не осталось место куда написать declaration specifiers, поэтому выбрали самый разумный default: decltype(auto).

Потому что declaration specifiers относятся к невидимой переменной которая справа от = Надо же как-то задавать хотим мы ее получать по ссылке или по значению. А для a, b уже не осталось место куда написать declaration specifiers, поэтому выбрали самый разумный default: decltype(auto).

Я понимаю как это работает, я не понимаю, ЗАЧЕМ оно так работает

т.е. если я пишу auto name = /*expression*/ я точно уверен, что name это не ссылка

ЗАТЕМ что выбирать declaration specifiers для того что справа от = важнее чем для того что слева от =

нет!

выражение справа является типичным expression для которого есть стандартные правила auto&&

прямо как в range-based for

for (auto x : expression) вы настраиваете x, а не expression

перенастройка expression делается одним оператором!

у меня в проекте он называется utils::copy_of

// //copy_of // template <typename T> std::decay_t<T> copy_of(T const& t) { return t; }

т.е. если я пишу auto name = /*expression*/ я точно уверен, что name это не ссылка

а это не ссылка: https://godbolt.org/g/hHc49Y

это что-то что ведет себя похоже на ссылку

как, скажем, class member

а это не ссылка: https://godbolt.org/g/hHc49Y

#include <functional> #include <utility> template <typename... Args> auto proxy(Args&&... args) { return std::forward_as_tuple<Args...>(args...); } int f() { int x = 0; auto [y] = proxy(x); auto z = std::get<0>(proxy(x)); y = 1; z = 2; return x; }

конструкция auto [y] объявляет ссылку

нет

функция выводит 1

это я понимаю, но это не ссылка см. https://godbolt.org/g/hHc49Y

выражение справа является типичным expression для которого есть стандартные правила auto&&

как тогда Вы запишите range-based for по std::map, если declaration specifiers будут относиться к тому что слева от = а не к тому что справа?

выражение справа является типичным expression для которого есть стандартные правила auto&&

Как я помню, оно там выводится из std::tuple_element Тоесть можно специализировать этот шаблон и получить другой тип Но это всё дурно пахнет

Как я помню, оно там выводится из std::tuple_element Тоесть можно специализировать этот шаблон и получить другой тип Но это всё дурно пахнет

Ну для реализации zip/adjacent/indexed нужно две версии писать

как тогда Вы запишите range-based for по std::map, если declaration specifiers будут относиться к тому что слева от = а не к тому что справа?

точно так же, вы не поверите

точно так же, вы не поверите

не поверю, пока Вы не напишите

Проблема в том, что такой код не компилируется struct pair { const int x = 1; int y; }; pair p; auto & x = p.x, & y = p.y;

auto & не может вывести одновременно Key const & и Value &

auto & не может вывести одновременно Key const & и Value &

https://godbolt.org/g/3VdBbw

подразумевается return p.y но сути не меняет

я имею в виду, что если в конструкции for (auto & [k, v] : ...) разрешить для одной компоненты вывести & а для другой const & будет как-то не очень

я имею в виду, что если в конструкции for (auto & [k, v] : ...) разрешить для одной компоненты вывести & а для другой const & будет как-то не очень

const int x = 0; int y = 0; [&x, &y] () {};

вот вам еще пример https://godbolt.org/g/PjPJGT

часть распаковки не модифицировалась

const int x = 0; int y = 0; [&x, &y] () {};

значок & в lambda capture не имеет отношения к declaration specifiers, просто такой же значок как для ссылок

значок & в lambda capture не имеет отношения к declaration specifiers, просто такой же значок как для ссылок

а по-моему [...] синтаксис объявляет класс и значок & приписывается к auto

а по-моему [...] синтаксис объявляет класс и значок & приписывается к auto

ну с очень большой натяжкой. а еще там const неявно приписывается

ну с очень большой натяжкой. а еще там const неявно приписывается

потому что у класса единственный метод, который const, безумно логично

То что Вы говорите примерами на godbolt звучит разумно — можно было бы сделать structured bindings так, как будно мы каждый компонент объявляем независимо. Но это бы тоже вызывало некоторый когнитивный диссонанс, потому что была бы разница между auto & x = ..., & y = ...; и auto & [x, y] = ....

ну с очень большой натяжкой. а еще там const неявно приписывается

https://godbolt.org/g/bwvN67 что характерно, не приписывается

только сигнатура метода const

#include <functional> #include <utility> template <typename... Args> auto proxy(Args&&... args) { return std::forward_as_tuple<Args...>(args...); } int f() { int x = 0; auto [y] = proxy(x); auto z = std::get<0>(proxy(x)); y = 1; z = 2; return x; }

пздц они там поехавшие

причем можно было сделать decltype(auto) [y] накрайняк

ну такто есть auto&&[]

да

auto [x, &y] тоже безумно логично в контексте

только сигнатура метода const

Да, ок, тут Вы правы. Я думал о const, потому что у лямбмд нет assignment operator.

лямбда-захватов

а expression по-прежнему на auto&& всегда получать

пздц они там поехавшие

хм... а может, писать не for (auto & [a, b] : zip_view(va, vb)) а for (auto & [a, b] : zip(std::ref(va), std::ref(vb))

и ref проифать?

std::reference_wrapper ифать, угу

&vector нельзя, указатели итерируемые

не будет на vector<int> some[2]; работать

хотя стоп. std::begin(T*) нельзя же

ты не можешь терять там тип

и ref проифать?

получается, можно еще for (auto & [a, b]: zip(&va, &vb))

https://godbolt.org/g/bwvN67 что характерно, не приписывается

вопрос неоднозначный: https://godbolt.org/g/oxKnsT

ты не можешь терять там тип

если передается ссылка, я могу всегда адрес взять

на массив? тип всрал

т.е. zip_view требует ссылку

ты можешь взять begin только пока не потерял тип

хм... хочешь сказать *std::addressof(x) это не тривиальный оператор?

я хочу сказать что надо брать begin(T (&)[N])

я требую, чтобы в случае ref-итерации мне передали addressof целевого

char va[15]; я не понял

zip(&va, &va)

вопрос неоднозначный: https://godbolt.org/g/oxKnsT

Короче clang и (gcc) просто обманывают: в unevaluated контексте они считают x не константным (и foo(x) резолвится в #1) а в обычном — константным (и foo(x) резолвится в #2). https://godbolt.org/g/RFksHu

zip(&va, &va)

https://godbolt.org/g/p5Var8