Perché l'ottimizzazione GCC non funziona con valarrays?

Question

Questo è un semplice programma in C++ utilizzando valarray:

#include <iostream> 
#include <valarray> 

int main() { 
    using ratios_t = std::valarray<float>; 

    ratios_t a{0.5, 1, 2}; 
    const auto& res (ratios_t::value_type(256)/a); 
    for(const auto& r : ratios_t{res}) 
     std::cout << r << " " << std::endl; 
    return 0; 
} 

Se compilo e correre in questo modo:

g++ -O0 main.cpp && ./a.out 

L'uscita è come previsto:

512 256 128 

Tuttavia, se Compilare ed eseguire in questo modo:

g++ -O3 main.cpp && ./a.out 

L'output è:

0 0 0 

Lo stesso accade se uso -O1 parametri di ottimizzazione.

versione GCC è (ultimo di Archlinux):

$ g++ --version 
g++ (GCC) 6.1.1 20160707 

Tuttavia, se provo con clangore, sia

clang++ -std=gnu++14 -O0 main.cpp && ./a.out 

e

clang++ -std=gnu++14 -O3 main.cpp && ./a.out 

producono lo stesso risultato corretto:

512 256 128 

versione Clang è:

$ clang++ --version 
clang version 3.8.0 (tags/RELEASE_380/final) 

Ho anche provato con GCC 4.9.2 su Debian, dove eseguibile produce il risultato corretto.

Si tratta di un possibile errore in GCC o sto facendo qualcosa di sbagliato? Qualcuno può riprodurlo?

EDIT: Sono riuscito a riprodurre il problema anche sulla versione Homebrew di GCC 6 su Mac OS.

Answer 1

valarray e auto non mescolare bene.

Questo crea un oggetto temporaneo, poi applica operator/ ad esso:

const auto& res (ratios_t::value_type(256)/a); 

Il libstdC++ valarray utilizza modelli di espressione in modo che operator/ restituisce un oggetto leggero che si riferisce agli argomenti originali e li valuta pigramente. Si utilizza const auto& che fa sì che il modello di espressione sia associato al riferimento, ma non estende la durata del temporaneo a cui fa riferimento il modello di espressione, quindi quando la valutazione avviene il temporaneo è uscito dall'ambito e la sua memoria è stata riutilizzato.

E funziona bene se lo fai:

ratios_t res = ratios_t::value_type(256)/a; 

Answer 2

E 'il risultato di una negligente attuazione operator/ (const T& val, const std::valarray<T>& rhs) (e molto probabilmente altri operatori oltre valarray) utilizzando la valutazione pigra:

#include <iostream> 
#include <valarray> 

int main() { 
    using ratios_t = std::valarray<float>; 

    ratios_t a{0.5, 1, 2}; 
    float x = 256; 
    const auto& res (x/a); 
    // x = 512; // <-- uncommenting this line affects the output 
    for(const auto& r : ratios_t{res}) 
     std::cout << r << " "; 
    return 0; 
} 

Con il "x = 512" linea commentata, l'uscita è

512 256 128 

Decommentare quella linea e l'output cambia in

1024 512 256 

Dato che nell'esempio l'argomento sul lato sinistro dell'operatore di divisione è temporaneo, il risultato non è definito.

UPDATE

Come Jonathan Wakely correttamente pointed out, l'implementazione basata pigro valutazione diventa un problema in questo esempio per l'utilizzo di auto.