Articles of c ++ 11

Undefinierter Verweis auf statisches constexpr char

Ich möchte ein static const char Array in meiner class haben. GCC beschwerte sich und sagte mir, ich sollte constexpr , obwohl es mir jetzt sagt, dass es eine undefinierte Referenz ist. Wenn ich das Array zu einem Nicht-Mitglied mache, kompiliert es. Was ist los? // .hpp struct foo { void bar(); static constexpr char […]

Ist die Rückkehr nach Rvalue Referenz effizienter?

beispielsweise: Beta_ab&& Beta::toAB() const { return move(Beta_ab(1, 1)); }

Nebenläufigkeit: Atomare und flüchtige in C ++ 11 Speichermodell

Eine globale Variable wird von zwei gleichzeitig ausgeführten Threads auf zwei verschiedenen coreen gemeinsam genutzt. Die Threads schreiben und lesen von den Variablen. Für die atomare Variable kann ein Thread einen veralteten Wert lesen? Jeder core kann einen Wert der gemeinsam genutzten Variablen in seinem Cache haben, und wenn ein Thread seine Kopie in einen […]

Rückgabe von unique_ptr aus functionen

unique_ptr erlaubt keinen Kopieraufbau, stattdessen unterstützt es die Bewegungssemantik. Dennoch kann ich ein unique_ptr von einer function zurückgeben und den zurückgegebenen Wert einer Variablen zuweisen. #include #include using namespace std; unique_ptr foo() { unique_ptr p( new int(10) ); return p; // 1 //return move( p ); // 2 } int main() { unique_ptr p = […]

Warum kann ich auto für einen privaten Typ verwenden?

Ich war irgendwie überrascht, dass der folgende Code kompiliert und ausgeführt wird (vc2012 & gcc4.7.2) class Foo { struct Bar { int i; }; public: Bar Baz() { return Bar(); } }; int main() { Foo f; // Foo::Bar b = f.Baz(); // error auto b = f.Baz(); // ok std::cout << bi; } Ist […]

Initialisierungslisten und RHS der Operatoren

Ich verstehe nicht, warum Initialisierungslisten nicht auf der RHS eines Operators verwendet werden können. Erwägen: class foo { }; struct bar { template bar(T const&…) { } }; foo& operator<<(foo& f, bar const&) { return f; } int main() { foo baz; baz << {1, -2, "foo", 4, 5}; return 0; } Der letzte Clang […]

Wie emuliert man C-Array-Initialisierung “int arr = {e1, e2, e3, …}” Verhalten mit std :: array?

(Hinweis: Bei dieser Frage muss die Anzahl der Elemente nicht angegeben werden, und verschachtelte Typen können weiterhin direkt initialisiert werden.) Diese Frage behandelt die für ein C-Array int arr[20]; Verwendungszwecke wie int arr[20]; . Auf seiner Antwort zeigt @James Kanze eine der letzten Hochburgen von C-Arrays, seine einzigartigen Initialisierungseigenschaften: int arr[] = { 1, 3, […]

shared_ptr zu einem Array: Soll es verwendet werden?

Nur eine kleine Frage zu shared_ptr . Ist es eine gute Vorgehensweise, shared_ptr zu verwenden, das auf ein Array verweist? Beispielsweise, shared_ptr sp(new int[10]); Wenn nicht, warum nicht? Ein Grund, der mir bereits bekannt ist, ist, dass man shared_ptr nicht inkrementieren / dekrementieren kann. Daher kann es nicht wie ein normaler pointers auf ein Array […]

Warum kann ich ein unique_ptr nicht in einen Vektor zurückschieben?

Was ist falsch an diesem Programm? #include #include int main() { std::vector<std::unique_ptr> vec; int x(1); std::unique_ptr ptr2x(&x); vec.push_back(ptr2x); //This tiny command has a vicious error. return 0; } Der Fehler: In file included from c:\mingw\bin\../lib/gcc/mingw32/4.5.0/include/c++/mingw32/bits/c++allocator.h:34:0, from c:\mingw\bin\../lib/gcc/mingw32/4.5.0/include/c++/bits/allocator.h:48, from c:\mingw\bin\../lib/gcc/mingw32/4.5.0/include/c++/memory:64, from main.cpp:6: c:\mingw\bin\../lib/gcc/mingw32/4.5.0/include/c++/bits/unique_ptr.h: In member function ‘void __gnu_cxx::new_allocator::construct(_Tp*, const _Tp&) [with _Tp = std::unique_ptr, _Tp* = […]

Sind die Tage des Übergebens const std :: string & als Parameter über?

Ich hörte kürzlich einen Vortrag von Herb Sutter, der vorschlug, dass die Gründe, std::vector und std::string by const & weitgehend weg sind. Er schlug vor, dass das Schreiben einer function wie der folgenden jetzt vorzuziehen ist: std::string do_something ( std::string inval ) { std::string return_val; // … do stuff … return return_val; } Ich verstehe, […]