On 12 Mai, 15:23, Arkaitz Jimenez <Arkai...@gmail.com> wrote:
For what I've seen around the operator-> is normally overloaded to
return the inner pointer in the case of a SmartPointer template.
However I was wondering if there is any way of having control after
the access was done, you can always execute code before returning the
pointer but obviously you can't after return.
So, is there anyway to get control before and after operator-> has its
effect?
Something like this?
struct do_nothing { void pre(){}; void post(){} };
template<typename T, typename U = T*,
typename prepost_func = do_nothing>
class ptrproxy
{
T* ptr;
public:
explicit ptrproxy(T* p) : ptr(p)
{ prepost_func().pre(); }
~ptrproxy()
{ prepost_func().post(); }
U operator->() const {return U(ptr);}
};
template<typename T, typename PrePost>
struct funky_pointer_metaf {
typedef ptrproxy<T,ptrproxy<T,T*,PrePost> > type;
};
#include <iostream>
struct S {
void blah()
{ std::cout << " --- S::blah ---\n"; }
};
struct my_prepost {
void pre() { std::cout << "prior access\n"; }
void post() { std::cout << "after access\n"; }
};
int main() {
S s;
typedef funky_pointer_metaf<S,my_prepost>::type funky_t;
funky_t p (&s);
p->blah();
p->blah();
}
which outputs:
prior access
--- S::blah ---
after access
prior access
--- S::blah ---
after access
?
destructor that will be called *at the end of full expression*. I