g ++ 6.1 è stato recentemente introdotto negli archivi di prova di Arch Linux e alcuni dei miei codici compilati con successo con g ++ 5.3.0 non sono più compilabili. Ho fatto un esempio minimo:Possibile std :: regressione diretta con g ++ 6.1 - bug o comportamento previsto?
// This code compiles with g++ 5.3.0
// This does not compile with g++ 6.1
#include <type_traits>
#include <utility>
#include <tuple>
#define FWD(...) ::std::forward<decltype(__VA_ARGS__)>(__VA_ARGS__)
struct sinker
{
template <typename T>
void sink(T&)
{
}
};
template <typename T, typename TF>
void caller(T& v, TF&& f)
{
sinker s;
f(s, v);
}
template <typename T>
void interface(T& v)
{
return caller(v, [](auto& xs, auto&& xv) -> decltype(auto)
{
xs.sink(FWD(xv));
});
}
int main()
{
int x = 0;
interface(x);
}
Questo è l'errore segnalato:
: In instantiation of ‘get_impl(T&)::<lambda(auto:1&, auto:2&&)> [with auto:1 = sinker; auto:2 = int; T = int]’:
:25:58: required by substitution of ‘template<class auto:1, class auto:2> get_impl(T&)
[with T = int]::<lambda(auto:1&, auto:2&&)>::operator
decltype (((get_impl(T&) [with T = int]::<lambda(auto:1&, auto:2&&)>)0u).operator()(static_cast<auto:1&>(<anonymous>),
static_cast<auto:2&&>(<anonymous>))) (*)(auto:1&, auto:2&&)() const [with auto:1 = sinker; auto:2 = int]’
:19:6: required from ‘void chunk_fn_impl(T&, TF&&) [with T = int; TF = get_impl(T&) [with T = int]::<lambda(auto:1&, auto:2&&)>]’
:25:25: required from ‘void get_impl(T&) [with T = int]’
:36:15: required from here
:27:13: error: invalid initialization of non-const reference of type ‘int&’ from an rvalue of type ‘int’
xs.sink(FWD(md));
^~
:10:10: note: initializing argument 1 of ‘void sinker::sink(T&) [with T = int]’
void sink(T&)
^~~~
Modifica:
return caller(v, [](auto& xs, auto&& xv) -> decltype(auto)
a:
return caller(v, [](auto& xs, auto& xv) -> decltype(auto)
consente al codice di compilare correttamente.
non capisco il motivo per cui questo errore sta accadendo, come xv è essere perfettamente trasmesso e la chiamata FWD(xv) dovrebbe produrre un riferimento lvalue. Si noti che il codice ha funzionato come previsto in g ++ 5.3.0 e clang ++ 3.7.
(provare a compilare con più versioni g ++ e cambiando auto&& a auto&.)
Si tratta di una g ++ 6.1 bug? Oppure il codice era compilato in modo errato con le versioni precedenti di g ++ e clang ++?
Niente a che vedere con 'forward'. Questo sembra un bug di frontend. –
Quel 'auto && 'significa che il lambda è un modello, che necessita della deduzione del tipo di argomento. Ma così è il 'caller'. Non capisco come questo possa mai essere compilato, dovrebbe essere bloccato nella deduzione all'infinitamente ricorsiva del tipo di argomento. Almeno secondo la mia comprensione primitiva di lambda con 'auto &&'. Qualcuno per favore spiega perché questo dovrebbe funzionare. – sp2danny
@ T.C. segnalato come [bug 70942] (https://gcc.gnu.org/bugzilla/show_bug.cgi?id=70942) –