std :: shared_ptr <T>: impliziter Konstruktor für rvalue Zeiger auf T

Question

Ich unterstütze ziemlich viel die Idee, std::shared_ptr<T> Konstruktor zu machen, der T * ausdrücklich akzeptiert. Es hilft, schlaflose Nacht zu sparen, wenn Sie den Grund auf Haufen Korruption suchen. Scott Meyers gab eine gute Erklärung dafür.

---

Aber ... Wenn ich es ein rvalue Zeiger geben, ist dies nicht ausdrücklich? Ich konnte Dinge tun, wie:

/// (1) 
std::shared_ptr<T> t = new T; 

oder

/// (2) 
T * giveaway = new T; 
std::shared_ptr<T> t = std::move(giveaway); 

oder ein viel schmerzhafter Fall aus dem wirklichen Leben

/// (3) 
void foo(std::shared_ptr<T> t); 
/// ... 
foo(new T); 

---

Was mich betrifft, alle diese Fälle sind deutlich genug .

Fall (1) ist ein prvalue, ich kann mich möglicherweise nicht mit zwei Zeigern vermasseln. Mindestens nicht mehr als mit:

std::shared_ptr<T> t{new T}; 

Fall (2) ist ziemlich explizit. Es ist vereinbart, dass nachdem du etwas bewegt hast, sein Wert undefiniert wird. Also, es ist total auf dich.

Fall (3) ist wieder ein rvalue.

---

(Q1) Es ist dies ein übersehen durch Standardkomitee?

(Q2) Gibt es einen Grund dafür?

(Q3) Gibt es eine Chance, dass der implizite Konstruktor rvalue in C++ 14 angezeigt wird?

Answer 1

Es gibt einen Grund sogar ein rvalue geben nicht zulässt, dass implizite Aufbau eines Smart-Zeiger von einem raw-Zeiger:

Es ist nicht sicher.

void foo(std::shared_ptr<T> t); 
char buffer[42]; 
foo(buffer+7); // buffer+7 is a rvalue, and would implicitly convert! 

So zu den anderen beiden Teile Ihrer Frage:

1. Es ist kein Versehen des Ausschusses.

Und

3. Es wird nicht in einer zukünftigen C erscheinen ++ - Standard (Wie auch immer, C 14 ++ sind und es tat nicht erscheinen).