Shared pointers and raw pointers in same container

Question

I need to populate container with shared pointers and raw pointers at same time.

I guess shared_ptr<T> may be forced to behave like T*, if constructed with no-op deleter and no-op (de)allocator?

Or may be there is universal smart pointer, which binds to different (smart and raw) pointer types?

Or may be shared_ptr can point to one object, but manage lifetime of another (nullptr) object of same type?

Background. I have simple component system. Some components are built-in, no management required, raw pointers will be enough. Other components are external DLLs, they must be attached when requested and detached when removed from "session". For latter I am using wrapper component, that will detach DLL when destroyed.

EDIT: Background updated.
EDIT2: Question updated.
EDIT3: Found straight solution. See my answer if interested.

Answer 1

Generally speaking, no; a container contains exactly one type of object.

You could use some kind of boost::variant<shared_ptr<T>, T*> object as the contained object. But you'd need visitors to access the elements of it. Alternatively, you can give boost::shared_ptr a special deleter object that doesn't actually delete the pointed-to value.

Answer 2

Well, it really depends on what your needs are, and more specifically what you would like to achieve in terms of ownerships:

1. Should your vector own the shared_ptr<T> ? (or could you just store the pointee ?)
2. Should your vector own the T* ?

Then there are varied solutions.

1. Full ownership: just encapsulate the T* in a regular shared_ptr<T>
2. Partial ownership: as stated, you can just instantiate a shared_ptr<T> with a no-op deleter to wrap the T*
3. No ownership: just unwrap the shared_ptr<T> using .get() and only store T*

Answer 3

Shared pointer may point to one object, but manage lifetime of another object. Curiously, it may manage nothing, but still point to something. There is special constructor, that accepts another shared pointer, that used to determine which object to share. We can pass empty shared pointer in it.

template <typename T>
std::shared_ptr<T> fake_shared(T *ptr)
{
    std::shared_ptr<T> dummy (nullptr); // we have nothing to manage;
    std::shared_ptr<T> faked (dummy, ptr); // but we have something to point to;
    return faked;
}

Moreover, we can exploit 2 facts. Firstly, this constructor will accept shared pointer of any (other) type. Secondly, std::shared_ptr<void> is legal, and may be used to express our intent more clearly.

template <typename T>
std::shared_ptr<T> fake_shared(T *ptr)
{
    std::shared_ptr<void> dummy (nullptr); // we have really nothing to manage;
    std::shared_ptr<T> faked (dummy, ptr); // but we have something to point to;
    return faked;
}

Alternatively, one may use constructor, that accepts custom deleter, and pass no-op deleter into it.

template <typename T>
std::shared_ptr<T> fake_shared(T *ptr)
{
    std::shared_ptr<T> faked (ptr, [](T *){}); // won't be deleted;
    return faked;
}

EDIT: Revision, shared void, custom deleter.