smart-pointers

This question already has an answer here: Which kind of pointer do I use when? 4 answers What are the best practices for using smart. Are there situations in which i should prefer using raw pointer instead of smart pointers? For example, if i know that class A creates class B and is the only owner of B - if there a reason to use smart pointers? If you know of any good articles on that subject, please share. If the pointer owns the object at any time, then use a smart pointer. If the pointer does not own the object (i.e. the object is owned by another smart pointer and guaranteed to outlive

The Rust documentation covers Rc<RefCell<T>> pretty extensively but doesn't go into RefCell<Rc<T>> , which I am now encountering. Do these effectively give the same result? Is there an important difference between them? Do these effectively give the same result? They are very different. Rc is a pointer with shared ownership while RefCell provides interior mutability. The order in which they are composed makes a big difference to how they can be used. Usually, you compose them as Rc<RefCell<T>> ; the whole thing is shared and each shared owner gets to mutate the contents. The effect of mutating

After reading on RAII, viewing Herb Sutter's CppCon2014 presentation , and reading the core guidelines and related articles over the course of some days, I'm still quite confused on ownership and related semantics. Let's say class A and class B represent physical entities, and there's a Scene class and a Process class. The Process class is a main function, if you will. In the real world, an A can acquire a B and physically keep it for itself. It can also release it. During the course of a Process instance, an A object must therefore be able to have for itself a B instance, and also to release

I wrote simple code to help me understand smart pointers: string s = "str"; vector <unique_ptr<string>> pv ; pv.push_back(unique_ptr<string>(&s)); cout<<*(pv[0])<<endl; This code compiles fine, but gets me a runtime error: str * Error in `...': munmap_chunk(): invalid pointer: 0x00007ffd956e57e0 * Aborted (core dumped) What happened and what have I done wrong? In the std::unique_ptr 's destructor it will call delete on the &s pointer which was not allocated via new . Just use: std::vector<std::string> vector; vector.emplace_back("str"); std::cout << pv[0] << std::endl; There's no need for std:

I'm trying to wrap a C++ library which uses auto_ptr. I'm using swig and want to generate python bindings. I'v seen the section of the swig docu on how to use swig with smart pointers here . But I can't get it to work. Swig generates code that wants to initialize the auto_ptr using a const reference, but auto_ptr defines the copy constructor with a non-const reference e.g. auto_ptr(auto_ptr &). The generated code does not compile with "discards const qualifiers". When I manually delete the const qualifier the code compiles fine. I'v seen lots of mailing list entries but nothing helped. Can