用静态或全局对象初始化共享指针

Question

The following code shows initializing a shared object with the address of a global or static object is not right as the global object gets deleted when the shared pointer goes out of scope.

class Dog() {
public:
    void bark() {
        cout << "Dog barks" << endl;
    }
};
Dog g_Dog;
void test() {
    shared_ptr<Dog> myDog(&g_Dog);
    myDog->bark();
}
int main() {

    test();

}

The above code crashes. My understanding is we should not initialize shared pointers with static or global object and should only do so with objects in the heap. Is that correct ?

I saw following code snippet in boost log tutorial ( https://www.boost.org/doc/libs/develop/libs/log/doc/html/log/tutorial/sinks.html )

#include <boost/core/null_deleter.hpp>

// We have to provide an empty deleter to avoid destroying the global stream object
boost::shared_ptr< std::ostream > stream(&std::clog, boost::null_deleter());
sink->locked_backend()->add_stream(stream);

Can you guys explain why the code

  boost::shared_ptr< std::ostream > stream(&std::clog, boost::null_deleter()); 

does not cause any problem. it looks like std::clog is aa glonal or a static variable. Isn't it ? why doesn't it pose the risk of getting destroyed when the above stream shared pointer goes out of scope. Please shed some light. Thanks

Answer 1

From the link null_deleter : boost::null_deleter function object can be used as a deleter with smart pointers such as unique_ptr or shared_ptr. The deleter doesn't do anything with the pointer provided upon deallocation, which makes it useful when the pointed object is deallocated elsewhere.

In other words, using the null_deleter, the smart pointer will never try to delete the pointed object.

Answer 2

It's legal if you provide a deleter which won't attempt to destroy and free it.

shared_ptr takes two arguments (check the documentation ): the address and a deleter. Deleter argument is optional.

The default deleter (ie the deleter used when you don't provide any explicitly) destroys the object and frees the heap, so it obviously won't work for anything not on the heap.

Answer 3

There are two options:

1. Use a nop-deleter. Just accept the overhead of that spurious control-block.

2. Use the aliasing constructor. std::weak_ptr s won't work with it though.
   See " Using C++ shared pointer's aliasing constructor with an empty shared pointer ".