Dangerous implizite Konvertierung in Emplace

Question

Der folgende Code kompiliert ohne Fehler/Warnungen mit gcc 6.3 (https://godbolt.org/g/sVZ8OH), aber es enthält ein gefährliches undefiniertes Verhalten aufgrund ungültigen Speicherzugriffs unten markiert. Die Ursache ist die implizite Konvertierung in emplace_back. Kann jemand einen guten Weg oder Best Practices vorschlagen, um solche Fehler im Code zu vermeiden?

#include <iostream> 
#include <vector> 

struct Foo 
{ 
    explicit Foo(const int& i) : i{i} {} 

    void foo() const { std::cout << i; } // invalid memory access, as i is an invalid ref!! 
    const int& i; 
}; 

void bar(const double& d) { 
    std::vector<Foo> fv; 
    fv.emplace_back(d); 
} 

Answer 1

Kann mir jemand eine gute Art und Weise oder Best Practices vorschlagen solche Fehler im Code zu vermeiden?

Wenn Ihre Klasse einen const Verweis auf ein anderes Objekt speichert, Sie, als Programmierer, nehmen die Verantwortung, dafür zu sorgen, dass Sie am Ende nicht eine baumelnde Referenz speichern.

Sofern Sie keinen starken Grund haben, eine const Referenz zu speichern, würde ich empfehlen, einen Wert zu speichern.

struct Foo 
{ 
    explicit Foo(const int& i) : i{i} {} 

    void foo() const { std::cout << i; } 
    int i; 
}; 

Answer 2

Wenn Sie eine konstante Referenz akzeptieren werden, aber Sie in einem temporären nicht wollen einen Verweis tun, einen zusätzlichen Konstruktor mit einem R-Wert Bezug Argumente erklären - und sie löschen.

struct Foo 
{ 
    explicit Foo(const int& i) : i{i} {} 
    explicit Foo(const int&& i) = delete; // This preferentially matches a reference to a 
             // temporary, and compilation fails. 

    void foo() const { std::cout << i; } // invalid memory access, as i is an invalid ref!! 
    const int& i; 
}; 

(nur ein int Ich gehe davon aus, dass das eigentliche Problem als komplexer ist. Für einen int, es von Wert hält, ist die richtige Antwort.)