How to convert an object instance to shared_ptr instance

Question

Suppose I had two shared_ptr types such as

boost::shared_ptr<ObjA> sptrA;
boost::shared_ptr<ObjB> sptrB;

Now suppose that sptrA->SomeMethod() returned a simple ObjB type (not a shared ptr). Is it possible for me to store that type somehow in sptrB ? So that I could do something like this so that the returned type instance is automatically converted to boost_shared ptr

sptrB = sptrA->SomeMethod();

I asked this question just of curiosity and whether it is possible or not ?

What exactly does `SomeMethod` return? A reference? A copy? A pointer? And how is that reference/copy/pointer created? — jogojapan, Oct 29 '12 at 04:16
`sptrB = boost::make_shared(sptrA->SomeMethod());` is an obvious answer, but that is not what you are looking for, right? Too complicated? — jogojapan, Oct 29 '12 at 04:28
@jogojapan that solved my problem. Can you post it as an answer please — Casper_2211, Oct 29 '12 at 06:17

jogojapan · Accepted Answer · 2012-10-29T06:37:50.020

The most standard way of creating boost:shared_ptr objects is to use the make_shared function provided by Boost:

#include <boost/shared_ptr.hpp>
#include <boost/make_shared.hpp>

struct A {};

A generator() {
  return A();
}

int main()
{
  using namespace boost;
  shared_ptr<A> p = make_shared<A>(generator());
  return 0;
}

Since the generator() function returns an A object by value, the syntax above implies that new is invoked with the copy contructor of A, and the resulting pointer is wrapped in a shared-pointer object. In other words, make_shared doesn't quite perform a conversion to shared pointer; instead, it creates a copy of the object on the heap and provides memory management for that. This may or may not be what you need.

Note that this is equivalent to what std::make_shared does for std::shared_ptr in C++11.

One way to provide the convenient syntax you mentioned in your question is to define a conversion operator to shared_ptr<A> for A:

struct A {
  operator boost::shared_ptr<A>() {
    return boost::make_shared<A>(*this);
  }
};

Then you can use it as follows:

shared_ptr<A> p = generate();

This will automatically "convert" the object returned by the function. Again, conversion here really means heap allocation, copying and wrapping in a shared pointer. Therefore, I am not really sure if I'd recommend defining such a convenience conversion operator. It makes the syntax very convenient, but it, as all implicit conversion operators, may also mean that you implicitly cause these "conversions" to happen in places you didn't expect.

score 2 · Answer 2 · answered Jul 29 '21 at 07:57

2

Since C++ 11 you can use std::make_shared<T>() function (link)

Example:

int a = 10;
std::shared_ptr<int> shared_a = std::make_shared<int>(a);

answered Jul 29 '21 at 07:57

Adam Kuzański

509
4
12

score 1 · Answer 3 · answered Oct 29 '12 at 04:32

This depends on precisely what ObjA::SomeMethod returns - a copy, a reference or a pointer. In the first two cases it would not be feasible to wrap it into a shared_ptr (because shared_ptr needs a pointer).

The third case is possible, but you must proceed with caution. Make sure that once you wrap a pointer to an object into a shared_ptr, no one else attempts to manage the lifetime of that object.

For example, if you return a raw pointer, wrap it into a shared pointer and then, at some point later in the program, someone deletes that same pointer, you will have a problem.

How to convert an object instance to shared_ptr instance

3 Answers3