Because of the fact that you you have the && version, it implies that you are planning on storing the shared ptr in your object.

The correct thing to do in this case is to have just one constructor, a constructor that takes the shared_ptr by value. You then treat the by value argument as you do in the in the shared_ptr&& version, using std::move to take the pointer.

This will handle all cases efficiently while only requiring one constructor.

In general, if you find yourself writing two versions of a function, one taking an Rvalue reference, you can probably use this optimisation. (Except for the actual move constructor of an object)

Your suggestion about the constructor signatures, however, won’t works. There are several problems with. Firstly, this set of constructors won’t allow initialization with a const reference to id:

const string id (”abc”);
lazy_shared_ptr<object> lp (db, id);

Then, there is the same problem when initializing with a non-const lvalue reference to shared_ptr. Instead of the second constructor, the first constructor will be called:

shared_ptr<object> p (…);
lazy_shared_ptr<object> lp (db, p);

object (object&& obj)
: base (std::move (obj)),
nums (std::move (obj.nums))
{
}

you use obj 2 times. Since the base constructor is called first, obj.nums can be set to an invalid value. Why? If the base constructor constructs an object using a move constructor, obj.nums could be invalidated leading to (I think) undefined behavior..
Am I completely off on this?

Hello. You seem to have miss the part about perfect forwarding when studying rvalue reference. The deduction rules are different when using rvalue reference and template. They are designed to allowed perfect forwading. Try this :

void inner(const int& i)
{
std::cout
void outer(T&& t)
{
inner(std::forward(t);
}

int i;
outer(i); // will go to inner(const int&)
outer(5); // will go to inner(int&&)

So in your case, you need only 3 constructors to lazy_shared_ptr. It should look like this :

// template case, perfect forward lvalue or rvalue all in one
template
lazy_shared_ptr (database& d, ID&& id)
{
d.init(std::forward(id));
}

// non template case, constructor for lvalue
template
lazy_shared_ptr (database& d, const std::shared_ptr& t)
{
d.init(t);
}

// non template case, constructor for rvalue
template
lazy_shared_ptr (database& d, std::shared_ptr&& t);
{
d.init(std::move(t));
}