Articles of c ++ 11

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, […]

C ++ 11 leitet keinen Typ ab, wenn std :: function- oder lambda-functionen beteiligt sind

Wenn ich diese function definiere, template set test(const set& input) { return input; } Ich kann es mit test(mySet) anderer Stelle im Code test(mySet) ohne den Template-Typ explizit definieren zu müssen. Wenn ich jedoch die folgende function verwende: template set filter(const set& input,function compare) { set ret; for(auto it = input.begin(); it != input.end(); it++) […]

Warum können In-Class-Initialisierer nur = oder {} verwenden?

In-Class-Initialisierer (C ++ 11-Feature) müssen in geschweiften Klammern eingeschlossen sein oder einem = -Zeichen folgen. Sie dürfen nicht in Klammern angegeben werden. Was ist der Grund dafür?

Ergibt “int size = 10;” einen konstanten Ausdruck?

Der folgende Code kompiliert unter gcc 4.8 und Clang 3.2: int main() { int size = 10; int arr[size]; } 8.3.4 / 1 des C ++ Standards besagt, dass die Größe eines Arrays ein ganzzahliger konstanter Ausdruck sein muss, dessen size nicht zu sein scheint. Ist das ein Fehler in beiden Compilern oder fehlt mir […]