std::vector<std::shared_ptr<std::mutex>> v;
v.push_back(std::shared_ptr<std::mutex>(new std::mutex()));

Aber so bekomme ich eine Fehlermeldung:

std::vector<std::shared_ptr<std::mutex>> v;
v.push_back(new std::mutex());

error C2664: 'void std::vector<_Ty>::push_back(std::shared_ptr<std::mutex> &&)' : cannot convert parameter 1 from 'std::mutex *' to 'std::shared_ptr<_Ty> &&'
1>          with
1>          [
1>              _Ty=std::shared_ptr<std::mutex>
1>          ]
1>          and
1>          [
1>              _Ty=std::mutex
1>          ]
1>          Reason: cannot convert from 'std::mutex *' to 'std::shared_ptr<_Ty>'
1>          with
1>          [
1>              _Ty=std::mutex
1>          ]
1>          Constructor for class 'std::shared_ptr<_Ty>' is declared 'explicit'
1>          with
1>          [
1>              _Ty=std::mutex
1>          ]

Sollte push_back nicht ein shared_ptr über folgenden Konstruktor erstellen?

template< class Y > 
explicit shared_ptr( Y* ptr );
Quelle: http://en.cppreference.com/w/cpp/memory/shared_ptr/shared_ptr

// blabla
{
    std::shared_ptr<std::mutex> tmp(new std::mutex());
    vec.push_back(tmp);
}
// blabla

Aber nicht (!!!) das hier:

// blabla
{
    vec.push_back(std::shared_ptr<std::mutex>(new std::mutex()));
}
// blabla

Denn wenn die Erzeugung des zweiten Argumentes eine Exception schmeißt, und von shared_ptr lediglich der new operator aufgerufen wurde, der shared_ptr selber aber noch nicht erzeugt wurde

Hmm.

§5.2.2/8 schrieb:

The evaluations of the postfix expression and of the argument expressions are all unsequenced relative to one another.

Aber wie leitest du daraus ab, dass die Auswertung eines Ausdrucks abrupt endet wenn in der Auswertung eines anderen eine Exception geworfen werden soll? Auch wenn die Ausdrücke gleichzeitig ausgewertet werden können,

§1.9/13 schrieb:

The execution of unsequenced evaluations can overlap.

werden sie komplett ausgewertet.

http://herbsutter.com/gotw/_102/

Bevor noch jemand denkt, dass sein C++ viel schlechter ist als er dachte:

void f( std::unique_ptr<T1>, std::unique_ptr<T2> );

Das ist kein gültiges C++, auch nicht C++11. Der Mensch kann halt kein HTML (oder mein Browser), das sollte

void f(std::unique_ptr<T1>, std::unique_ptr<T2>);

heißen

Ich dachte, es steht irgendwo, dass die Auswertung eines Ausdrucks auch definitiv die komplette Auswertung aller Sub-Ausdrücke beinhaltet.

Hättest nur mal an && und || gedacht. :p

Sone schrieb:

Ich dachte, es steht irgendwo, dass die Auswertung eines Ausdrucks auch definitiv die komplette Auswertung aller Sub-Ausdrücke beinhaltet.

Hättest nur mal an && und || gedacht. :p

Das meinte ich gar nicht. Ich meinte, dass wenn ein Ausdruck ausgewertet wird, definitiv alles auf einmal ausgewertet wird - sprich, wenn ich schreibe,
f(g(expr), h(expr2)) , dass dann nicht zuerst expr und danach expr2 ausgewertet wird, sondern sobald die Auswertung von expr angefangen hat, auch g aufgerufen wird und definitiv nichts dazwischen. Dass sozusagen die Auswertung konsistent ist.

Oder allgemeiner gefragt, wieso gibt der Standard nicht Evaluationsreihenfolgen vor?

Was sind eigentlich Gründe für sowas?

Oder allgemeiner gefragt, wieso gibt der Standard nicht Evaluationsreihenfolgen vor?

Dachte, weil es für den Compiler damit einfacher ist, Optimierungen vorzunehmen.

Was sind eigentlich Gründe für sowas?

Oder allgemeiner gefragt, wieso gibt der Standard nicht Evaluationsreihenfolgen vor?

Folge krümelkackers Link