C++ pointer spoofing - c++11

Question

I am currently working on a piece of code in which lots of pointers are used without proper ownership control. In some cases, it becomes a huge contraint because everything has to be initialized properly and can't be changed afterwards. So far I have been using dummy wrappers
// MyObject.h
struct MyObject
{
virtual int myMethod(int i){ return i; }
};
struct MyObjectWrapper : MyObject
{
MyObject *obj = nullptr;
int myMethod(int i){ if(obj) return obj->myMethod(i); }
void setObject(MyObject *obj){ this->obj = obj; }
}
// MyObjectFactory.h
MyObject *createMyObject(){
MyObject *object = new MyObject();
MyObjectWrapper *wrapper = new MyObjectWrapper();
wrapper->setObject(object);
return wrapper;
}
I am wondering if there is a way to do pointer "spoofing" by returning an object that is not actually a pointer but has the type of one, so that I can return a smart pointer instead of the regular pointer without changing the rest of the code. Is there a way of achieving that?
Additionnally, this led me to think about boost::optional. How is it implemented? Is boost using a lot of preprocessing for reflection? I cannot understand how it is possible to "intercept" a method call on a variable without neither knowing the name of the method nor using heavy preprocessing.
In case the answers are simple NOs, are you aware of any design pattern that can be used to work around my issues?

Answer 1

Ya know. It's time for the "Don't Defend Against Macchiavelli¹" talk. You'll always be able to know the address of an object if you have access to the object.
If you don't trust your users for that, don't give them access.
This is why the e.g. the OS kernel gives out opaque handles (aside from technical reasons).
In case your question was "Can I automatically create a proxy object" the answer is NO:
not without code generation tools
not without overloadable operator. (which doesn't currently exist outside of language proposals)
¹ e.g. http://www.gotw.ca/gotw/076.htm

Answer 2

You want a type that can store a dumb pointer or a smart pointer relatively transparently? Well, this isn't a good plan, but it can be done:
namespace details {
template<template<class...>class Z, class, class...Ts>
struct can_apply:std::false_type {};
template<template<class...>class Z, class...Ts>
struct can_apply<Z, std::void_t<Z<Ts...>>, Ts...>:std::true_type{};
}
template<template<class...>class Z, class...Ts>
using can_apply = details::can_apply<Z,void,Ts...>;
template<class T>
using dot_get_r = decltype( std::declval<T>().get() );
template<class T>
using can_get = can_apply< dot_get_r, T >;
template<class T>
struct ptr_like {
T* get()const{
if (!pvtable && !pimpl) return nullptr;
return pvtable->get(pimpl.get());
}
explicit operator bool() const{ return !!get(); }
// wall of == <= etc:
friend bool operator==( ptr_like const& ptr, std::nullptr_t ) { return !(bool)ptr; }
friend bool operator==( std::nullptr_t, ptr_like const& ptr ) { return !(bool)ptr; }
friend bool operator!=( ptr_like const& ptr, std::nullptr_t ) { return (bool)ptr; }
friend bool operator!=( std::nullptr_t, ptr_like const& ptr ) { return (bool)ptr; }
friend bool operator==( ptr_like const& lhs, ptr_like const& rhs ) {return lhs.get()==rhs.get();}
friend bool operator!=( ptr_like const& lhs, ptr_like const& rhs ) {return lhs.get()!=rhs.get();}
friend bool operator<=( ptr_like const& lhs, ptr_like const& rhs ) {return lhs.get()<=rhs.get();}
friend bool operator>=( ptr_like const& lhs, ptr_like const& rhs ) {return lhs.get()>=rhs.get();}
friend bool operator<( ptr_like const& lhs, ptr_like const& rhs ) {return lhs.get()<rhs.get();}
friend bool operator>( ptr_like const& lhs, ptr_like const& rhs ) {return lhs.get()>rhs.get();}
template<class U,
std::enable_if_t< std::is_convertible<U*, T*>{}, int > =0
>
friend bool operator==( ptr_like const& lhs, ptr_like<U> const& rhs ) { return lhs.get()==rhs.get(); }
template<class U,
std::enable_if_t< std::is_convertible<U*, T*>{}, int > =0
>
friend bool operator==( ptr_like<U> const& lhs, ptr_like const& rhs ) { return lhs.get()==rhs.get(); }
template<class U,
std::enable_if_t< std::is_convertible<U*, T*>{}, int > =0
>
friend bool operator!=( ptr_like const& lhs, ptr_like<U> const& rhs ) { return lhs.get()!=rhs.get(); }
template<class U,
std::enable_if_t< std::is_convertible<U*, T*>{}, int > =0
>
friend bool operator!=( ptr_like<U> const& lhs, ptr_like const& rhs ) { return lhs.get()!=rhs.get(); }
template<class U,
std::enable_if_t< std::is_convertible<U*, T*>{}, int > =0
>
friend bool operator<=( ptr_like const& lhs, ptr_like<U> const& rhs ) { return lhs.get()<=rhs.get(); }
template<class U,
std::enable_if_t< std::is_convertible<U*, T*>{}, int > =0
>
friend bool operator<=( ptr_like<U> const& lhs, ptr_like const& rhs ) { return lhs.get()<=rhs.get(); }
template<class U,
std::enable_if_t< std::is_convertible<U*, T*>{}, int > =0
>
friend bool operator>=( ptr_like const& lhs, ptr_like<U> const& rhs ) { return lhs.get()>=rhs.get(); }
template<class U,
std::enable_if_t< std::is_convertible<U*, T*>{}, int > =0
>
friend bool operator>=( ptr_like<U> const& lhs, ptr_like const& rhs ) { return lhs.get()>=rhs.get(); }
template<class U,
std::enable_if_t< std::is_convertible<U*, T*>{}, int > =0
>
friend bool operator<( ptr_like const& lhs, ptr_like<U> const& rhs ) { return lhs.get()<rhs.get(); }
template<class U,
std::enable_if_t< std::is_convertible<U*, T*>{}, int > =0
>
friend bool operator<( ptr_like<U> const& lhs, ptr_like const& rhs ) { return lhs.get()<rhs.get(); }
template<class U,
std::enable_if_t< std::is_convertible<U*, T*>{}, int > =0
>
friend bool operator>( ptr_like const& lhs, ptr_like<U> const& rhs ) { return lhs.get()>rhs.get(); }
template<class U,
std::enable_if_t< std::is_convertible<U*, T*>{}, int > =0
>
friend bool operator>( ptr_like<U> const& lhs, ptr_like const& rhs ) { return lhs.get()>rhs.get(); }
// -> and unary * support:
T* operator->()const{ return get(); }
T& operator*()const{ return *get(); }
// move:
ptr_like(ptr_like&&)=default;
ptr_like& operator=(ptr_like&&)=default;
// copy:
ptr_like(ptr_like const& o):
pvtable(o.pvtable),
pimpl(o.clone())
{}
ptr_like& operator=(ptr_like const& o) {
auto tmp = o;
swap(*this, tmp);
return *this;
}
// swap:
friend void swap( ptr_like& lhs, ptr_like& rhs ) {
using std::swap;
swap(lhs.vtable, rhs.vtable);
swap(lhs.pimpl, rhs.pimpl);
}
// Construct from smart pointer:
template<class Smart,
class dSmart = std::decay_t<Smart>,
std::enable_if_t< can_get<dSmart const&>{} && !std::is_same<dSmart, ptr_like>{}, int > =0
>
ptr_like( Smart&& smart ):
pvtable( smart_vtable<dSmart>() ),
pimpl( unique_ptr_with_deleter(std::forward<Smart>(smart)) )
{}
// construct from dumb pointer:
template<class Dumb>
ptr_like( Dumb* dumb ):
pvtable( pointer_vtable<Dumb>() ),
pimpl( unique_ptr_with_deleter(dumb) )
{}
private:
using state = std::unique_ptr<void, void(*)(void*)>;
struct vtable {
T* (*get)(void*) = 0;
state (*clone)(state const&) = 0;
};
vtable const* pvtable = nullptr;
state pimpl;
state clone() const {
if (!pimpl||!pvtable) return {nullptr, [](void*){}};
return pvtable->clone( pimpl );
}
template<class U,
class dU = std::decay_t<U>
>
static state unique_ptr_with_deleter(U&& u) {
std::unique_ptr<void, void(*)(void*)> r
= {
new dU(std::forward<U>(u)),
[](void* ptr){
delete static_cast<dU*>(ptr);
}
};
return r;
}
template<class U>
static vtable const* pointer_vtable() {
static vtable const table = make_ptr_vtable<U>();
return &table;
}
template<class O>
static vtable const* smart_vtable() {
static vtable const table = make_smart_vtable<O>();
return &table;
}
template<class U>
static vtable make_ptr_vtable() {
return {
[](void* ptr)->T*{
return *static_cast<U**>(ptr);
},
[](state const& ptr)->state{
return {ptr.get(), ptr.get_deleter()};
}
};
}
template<class O>
static vtable make_smart_vtable() {
return {
[](void* ptr)->T*{
O* o = static_cast<O*>(ptr);
return o?o->get():nullptr;
},
[](state const& ptr)->state{
O* o = static_cast<O*>(ptr.get());
if (!o) return {nullptr, ptr.get_deleter()};
return {new O(*o), ptr.get_deleter()};
}
};
}
};
note that unique_ptr does not qualify, as it cannot be copied while dumb pointers can. Custom smart pointers (that can be copied) can be used. We could extend this to having it throw/terminate if you pass it a non-copyable smart pointer and that value is copied instead of moved, if you where even more insane than this answer.
Live example. Code is C++1z, and no I'm not making it C++11 or 14, it is a dumb idea to start with.
Code is incomplete -- nullptr < p doesn't work, for example. Code is less than perfectly efficient (I could store dumb pointers more efficiently, and use SBO even for smart pointers). Needs std::less specialization or have < use it.
But it is a proof of concept.
int foo( ptr_like<int> ptr ) {
if (!ptr) return -1;
return *ptr+1;
}
will compile. The ptr_like<int> could be an int* or a std::shared_ptr<int> it won't care. You can persist the ptr_like<int> and copy it around. Copies of shared_ptr<int>s will maintain reference counts, copies of int* won't.
If you use this, you'll end up with a code base that is harder to maintain, not easier, as object lifetime will get more confusing, not less.