std :: unique_ptr to inteligentny wskaźnik, który zachowuje wyłączną własność obiektu za pośrednictwem wskaźnika. unique_ptr nie jest kopiowalny ani przypisywany do kopiowania, dwie instancje unique_ptr nie mogą zarządzać tym samym obiektem.
Jestem nowy, aby przenieść semantykę w C ++ 11 i nie wiem zbyt dobrze, jak obsługiwać unique_ptrparametry w konstruktorach lub funkcjach. Rozważ tę klasę, która sama się odwołuje: #include <memory> class Base { public: typedef unique_ptr<Base> UPtr; Base(){} Base(Base::UPtr n):next(std::move(n)){} virtual ~Base(){} void setNext(Base::UPtr n) { next = std::move(n); } …
unique_ptr<T>nie zezwala na tworzenie kopii, zamiast tego obsługuje semantykę przenoszenia. Jednak mogę zwrócić a unique_ptr<T>z funkcji i przypisać zwróconą wartość do zmiennej. #include <iostream> #include <memory> using namespace std; unique_ptr<int> foo() { unique_ptr<int> p( new int(10) ); return p; // 1 //return move( p ); // 2 } int main() …
Mam trochę kodu w nagłówku, który wygląda następująco: #include <memory> class Thing; class MyClass { std::unique_ptr< Thing > my_thing; }; Jeśli dołączę ten nagłówek do cpp, który nie zawiera Thingdefinicji typu, wówczas nie kompiluje się w VS2010-SP1: 1> C: \ Program Files (x86) \ Microsoft Visual Studio 10.0 \ VC …
std::unique_ptr obsługuje tablice, na przykład: std::unique_ptr<int[]> p(new int[10]); ale czy jest to potrzebne? prawdopodobnie jest wygodniejszy w użyciu std::vectorlub std::array. Czy znajdujesz zastosowanie dla tego konstruktu?
Co jest nie tak z tym programem? #include <memory> #include <vector> int main() { std::vector<std::unique_ptr<int>> vec; int x(1); std::unique_ptr<int> ptr2x(&x); vec.push_back(ptr2x); //This tiny command has a vicious error. return 0; } Błąd: 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<_Tp>::construct(_Tp*, const …
Dlaczego std::make_uniquew standardowej bibliotece C ++ 11 nie ma szablonu funkcji? znajduję std::unique_ptr<SomeUserDefinedType> p(new SomeUserDefinedType(1, 2, 3)); trochę gadatliwy. Czy poniższe rzeczy nie byłyby o wiele ładniejsze? auto p = std::make_unique<SomeUserDefinedType>(1, 2, 3); To newładnie ukrywa i wspomina o typie tylko raz. Tak czy inaczej, oto moja próba wdrożenia make_unique: …
Używam idiomu pimpl z std::unique_ptr: class window { window(const rectangle& rect); private: class window_impl; // defined elsewhere std::unique_ptr<window_impl> impl_; // won't compile }; Jednak pojawia się błąd kompilacji dotyczący użycia niekompletnego typu w wierszu 304 w <memory>: Nieprawidłowe zastosowanie „ sizeof” do niekompletnego typu uixx::window::window_impl” O ile mi wiadomo, std::unique_ptrpowinno …
Wraz z nadejściem nowego standardu (i części już dostępnych w niektórych kompilatorach) nowy typ std::unique_ptrma być zamiennikiem std::auto_ptr. Czy ich użycie dokładnie się pokrywa (więc mogę dokonać globalnego wyszukiwania / zamiany w moim kodzie (nie żebym to zrobił, ale gdybym to zrobił)), czy powinienem być świadomy pewnych różnic, które nie …
Mam problem ze zrozumieniem użycia inteligentnych wskaźników jako członków klasy w C ++ 11. Dużo czytałem o inteligentnych wskazówkach i myślę, że rozumiem, jak unique_ptri shared_ptr/ weak_ptrdziała ogólnie. To, czego nie rozumiem, to prawdziwe użycie. Wygląda na to, że wszyscy zalecają używanie unique_ptrgo prawie cały czas. Ale jak bym zaimplementował …
Mam klasę z członkiem unique_ptr. class Foo { private: std::unique_ptr<Bar> bar; ... }; Bar jest klasą strony trzeciej, która ma funkcje create () i niszczą (). Gdybym chciał użyć std::unique_ptrz nim jako samodzielnej funkcji, mógłbym zrobić: void foo() { std::unique_ptr<Bar, void(*)(Bar*)> bar(create(), [](Bar* b){ destroy(b); }); ... } Czy można …
Czy std::make_uniquema jakieś korzyści związane z wydajnością std::make_shared? W porównaniu z tworzeniem ręcznym std::unique_ptr: std::make_unique<int>(1); // vs std::unique_ptr<int>(new int(1));
Czy biblioteka standardowa C ++ 11 zapewnia narzędzie do konwersji z formatu a std::shared_ptrna std::unique_ptrlub odwrotnie? Czy to bezpieczna operacja?
Jak mogę przekazać a std::unique_ptrdo funkcji? Powiedzmy, że mam następującą klasę: class A { public: A(int val) { _val = val; } int GetVal() { return _val; } private: int _val; }; Następujące elementy nie są kompilowane: void MyFunc(unique_ptr<A> arg) { cout << arg->GetVal() << endl; } int main(int argc, …
Pytanie naprawdę pasuje do tytułu: jestem ciekawy, jaki jest techniczny powód tej różnicy, ale także uzasadnienie? std::shared_ptr<void> sharedToVoid; // legal; std::unique_ptr<void> uniqueToVoid; // ill-formed;
Używamy plików cookie i innych technologii śledzenia w celu poprawy komfortu przeglądania naszej witryny, aby wyświetlać spersonalizowane treści i ukierunkowane reklamy, analizować ruch w naszej witrynie, i zrozumieć, skąd pochodzą nasi goście.
Kontynuując, wyrażasz zgodę na korzystanie z plików cookie i innych technologii śledzenia oraz potwierdzasz, że masz co najmniej 16 lat lub zgodę rodzica lub opiekuna.