c++ - compile - llvm 3.7 0

Diferentes resultados en Clang y GCC al convertir a std:: opcional<T>

Question

Dado el siguiente código:

#include <iostream>
#include <optional>

struct foo
{
    explicit operator std::optional<int>() {
        return std::optional<int>( 1 );
    }
    explicit operator int() {
        return 0;
    }
};

int main()
{
    foo my_foo;
    std::optional<int> my_opt( my_foo );
    std::cout << "value: " << my_opt.value() << std::endl;
}

gcc 7.2.0 escribe el value: 1 .

MSVC 2017 (15.3) y clang 4.0.0 sin embargo, escriba el value: 0 .

¿Cuál es correcto de acuerdo con el estándar C ++?

Answer 1

Como se trata de una inicialización directa, enumeramos los constructores y simplemente seleccionamos el mejor. Los constructores relevantes para std::optional son:

constexpr optional( const optional& other ); // (2)
constexpr optional( optional&& other ) noexcept(/* see below */); // (3)

template < class U = value_type >
/* EXPLICIT */ constexpr optional( U&& value ); // (8), with U = foo&

Ambos son viables ( (8) solo participa en la resolución de sobrecarga si int es construible desde foo& y foo no es std::in_place_t ni std::optional<int> , todos los cuales se mantienen), pero (8) es una coincidencia exacta mientras que (2) y (3) requieren una conversión definida por el usuario, por lo que se debe preferir. gcc está mal aquí.

Sin embargo, gcc tampoco invoca (3) . Simplemente inicializa my_opt directamente del resultado de convertir my_foo a un optional<int> . Este programa con gcc 7.2 imprime 3 pero ninguno de 1a , 1b o 2 :

#include <iostream>

template <class T>
struct opt {
    opt() { }
    opt(opt const& ) { std::cout << "1a/n"; }
    opt(opt&& ) { std::cout << "1b/n"; }

    template <class U>
    opt(U&& ) { std::cout << "2/n"; }
};

struct foo 
{
    explicit operator opt<int>() { std::cout << "3/n"; return {}; }
};

int main()
{
    opt<int> o(foo{});
}

No creo que sea una ruta permisible. Archivé 81952 .