Virtual move constructor in C++ - c++

Question

Just faced with a situation and don't know what to do... Here is the code I have right now:
class IMyDbAccessor {
public:
int getSum(); // quite important for my case that it is not const.
// it does some caching. Of course I may use mutable,
// but actually it is not that important here.
};
void SomeBusinessLogic(IMyDbAccessor& dbacc) { /* implementation */ }
int main(int argc, char** argv) {
MyDbAccessor acc(argv);
SomeBusinessLogic(acc);
}
I don't like it, because it is not expressive enough. I would like to have
void SomeBusinessLogic(IMyDbAccessor&& dbacc) { /* implementation */ }
to show that SomeBusinessLogic wants to own a passed object, so main should look like
int main(int argc, char** argv) {
MyDbAccessor acc(argv);
SomeBusinessLogic(std::move(acc));
}
But of course it is impossible... Does anyone know what was a reasoning for that? For me it makes a perfect sense.
Or my feelings are wrong and I should not make SomeBusinessLogic responsible for IMyDbAccessor ownership, so it's better to pass it as a const IMyDbAccessor&?

Answer 1

I don't like it, because it is not expressive enough.
Looks plenty expressive to me. Passing an object by reference means the function can operate on an existing object provided by the caller, not on a copy. No worries about managing ownership.
I would like to have
void SomeBusinessLogic(IMyDbAccessor&& dbacc) { /* implementation */ }
to show that SomeBusinessLogic wants to own a passed object
That is not what an rvalue reference represents. An rvalue reference means that dbacc will refer to either a temporary object created by the compiler at the actual call site, or a pre-existing object that the caller passes with std::move(). Either way, the object that dbacc refers to is expected not to be used anymore after SomeBusinessLogic() exits, so SomeBuinessLogic() is allowed to "steal" ownership of any internal data held by the object that dbacc refers to, instead of make copies of it. This has nothing to do with ownership of the object itself. That still lies strictly with the caller.
so main should look like
int main(int argc, char** argv) {
MyDbAccessor acc(argv);
SomeBusinessLogic(std::move(acc));
}
But of course it is impossible...
What you are looking for is std::unique_ptr:
void SomeBusinessLogic(std:::unique_ptr<IMyDbAccessor> dbacc) { /* implementation */ }
int main(int argc, char** argv) {
std::unique_ptr<IMyDbAccessor> acc(new MyDbAccessor(argv));
SomeBusinessLogic(std::move(acc));
}
Or:
int main(int argc, char** argv) {
SomeBusinessLogic(std::make_unique<MyDbAccessor>(argv));
}
Only one std::unique_ptr at a time should ever hold a given pointer, as std::unique_ptr frees the memory being pointed at when destructed. That is what makes it "unique". When you see a std::unique_ptr, you know who the owner is. And passing a std::unique_ptr object by value to a function means it exists only for the lifetime of the function.
So, this approach makes it very clear that dbacc itself, not the caller, holds exclusive ownership of the IMyDbAccessor object, and will free that object when SomeBusinessLogic() exits (unless SomeBusinessLogic() decides to std::move() dbacc to another std::unique_ptr that is outside of SomeBusinessLogic()).
Or my feelings are wrong and I should not make SomeBusinessLogic responsible for IMyDbAccessor ownership, so it's better to pass it as a const IMyDbAccessor&?
I would, yes. Unless there is some compelling reason that SomeBusinessLogic() must take ownership away from the caller.

Answer 2

I think the type you are looking for is probably void SomeBusinessLogic(std::unique_ptr<IMyDbAccessor>)?
Indicates ownership is being transferred, and accepts derived objects

Answer 3

Do SomeBusinessLogic(std::forward(acc)).
For example:
#include <iostream>
#include <utility>
class IMyDbAccessor {
public:
virtual int getSum() = 0;
};
class MyDbAccessor : public IMyDbAccessor {
public:
virtual int getSum() { return 0; }
};
void SomeBusinessLogic(IMyDbAccessor&& dbacc) { std::cout << dbacc.getSum() << std::endl; }
int main(int argc, char** argv) {
MyDbAccessor acc;
SomeBusinessLogic(std::forward<MyDbAccessor>(acc));
}
Try it here:
http://cpp.sh/7pbrm

Answer 4

If you are looking for a way to give feedback "Hey I will modify this variable!" at the call location, I strongly recommend const pointers.
Then you have:
void SomeBusinessLogic(IMyDbAccessor* const dbacc) { /* implementation */ }
and
int main(int argc, char** argv) {
MyDbAccessor acc;
SomeBusinessLogic(&acc);
}