unique-ptr

问题 I was trying my hand with allocators this time & felt that there were many chances of leaking the resources. So I thought what if I used std::unique_ptr to handle them. I tried my hand with a std::vector 's allocator. My code goes like this :- // allocator #include <iostream> #include <vector> #include <memory> using namespace std; class X { int x,ID; static int i; public: X() { cout<<"constructing "; ID=++i; cout<<"ID="<<ID<<'\n'; } X(int a) { x=a; cout<<"constructing "; ID=++i; cout<<"ID="<

问题 I'm trying to compile some code, which reduces to this: #include <memory> #include <vector> #include <QString> class Category { std::vector<std::unique_ptr<int>> data; QString name; }; int main() { std::vector<Category> categories; categories.emplace_back(); }; Compiled as is, it results in the following error from g++ and similar for clang++: In file included from /opt/gcc-4.8/include/c++/4.8.2/memory:64:0, from test.cpp:1: /opt/gcc-4.8/include/c++/4.8.2/bits/stl_construct.h: In

问题 I'm trying to compile some code, which reduces to this: #include <memory> #include <vector> #include <QString> class Category { std::vector<std::unique_ptr<int>> data; QString name; }; int main() { std::vector<Category> categories; categories.emplace_back(); }; Compiled as is, it results in the following error from g++ and similar for clang++: In file included from /opt/gcc-4.8/include/c++/4.8.2/memory:64:0, from test.cpp:1: /opt/gcc-4.8/include/c++/4.8.2/bits/stl_construct.h: In

问题 Let's say I have the following hierarchy of classes: struct Base { }; struct Derived : public Base { void DoStuffSpecificToDerivedClass() { } }; And the following factory method: std::unique_ptr<Base> factoryMethod() { auto derived = std::make_unique<Derived>(); derived->DoStuffSpecificToDerivedClass(); return derived; // does not compile } The problem is, the return statement does not compile, because std::unique_ptr does not have a copy constructor with covariance support (which makes sense

问题 I like the new pointer types in C++11, but sometimes I still need a raw pointer. Something that makes me increasingly sad about "raw" types in C++, however, is their habit of initializing as undefined when not given an explicit value. As I use std::shared_ptr<> and the like more often, this need to initialize raw pointers to null feels increasingly brittle and unnecessary. I'm talking about: class foo { ... std::shared_ptr< bar > pb; // Initially null in whatever constructor. std::unique_ptr<

问题 Let's say I have a library which has a Document class. An instance of Document can own several instances of Field . Field has multiple subclasses (for example IntegerField and StringField ), and even the API user can subclass it and supply subclass instances to Document (let's say the user is allowed to develop a custom type of data to store in a field). I'd like to expose the Field instances owned by Document through an API in such a way that users can interact with them, but without

问题 Let's say I have a library which has a Document class. An instance of Document can own several instances of Field . Field has multiple subclasses (for example IntegerField and StringField ), and even the API user can subclass it and supply subclass instances to Document (let's say the user is allowed to develop a custom type of data to store in a field). I'd like to expose the Field instances owned by Document through an API in such a way that users can interact with them, but without

问题 std::vector has the member function at() as a safe alternative to operator[] , so that bound checking is applied and no dangling references are created: void foo(std::vector<int> const&x) { const auto&a=x[0]; // What if x.empty()? Undefined behavior! const auto&a=x.at(0); // Throws exception if x.empty(). } However, std::unique_ptr lacks the corresponding functionality: void foo(std::unique_ptr<int> const&x) { const auto&a=*x; // What if bool(x)==false? Undefined behavior! } It would be great

问题 Is unique_ptr thread safe? Is it impossible for the code below to print same number twice? #include <memory> #include <string> #include <thread> #include <cstdio> using namespace std; int main() { unique_ptr<int> work; thread t1([&] { while (true) { const unique_ptr<int> localWork = move(work); if (localWork) printf("thread1: %d\n", *localWork); this_thread::yield(); } }); thread t2([&] { while (true) { const unique_ptr<int> localWork = move(work); if (localWork) printf("thread2: %d\n",

问题 One of my function takes a vector as a parameter and stores it as a member variable. I am using const reference to a vector as described below. class Test { public: void someFunction(const std::vector<string>& items) { m_items = items; } private: std::vector<string> m_items; }; However, sometimes items contains a large number of strings, so I'd like to add a function (or replace the function with a new one) that supports move semantics. I am thinking of several approaches, but I'm not sure