Specialize member pointer template argument resolution - c++

Question

Having guard class on C++11 that is responsible to invoke some member function on scope exit:
template <class T, void (T::*op)()>
struct Guard
{
Guard(T*g):
_g(g){}
~Guard()
{
(_g->*op)();
}
T*_g;
};
Usage is very simple:
typedef Guard<Foo, &Foo::bar> FooGuard;
...
FooGuard g(&foo);
My question originated from existing shared_ptr<Foo>. How to create specialization that keeps shared_ptr<T> instead of T*
What I've already tried:
template <class T, void (T::*op)()>
struct Guard<std::shared_ptr<T>, op>
{
Guard(std::shared_ptr<T>& g):
_g(g){}
~Guard()
{
((*_g).*op)();
}
std::shared_ptr<T> _g;
};
But during compilation on G<std::shared_ptr<Foo>, &Foo::bar> g2(foo); have foreseeable got:
error C2440: 'specialization' : cannot convert from 'overloaded-function' to 'void (__thiscall std::shared_ptr::* )(void)'

Answer 1

as #PiotrSkotnicki already pointed out, your specialization is not valid.
You could use something like the following, however the interface does not look that nice:
template <class T, class U, void (U::*op)()>
struct Guard
{
Guard(T*g):
_g(g){}
~Guard()
{
std::cout << "normal guard" << std::endl;
(_g->*op)();
}
T*_g;
};
template <class T, class U, void (U::*op)()>
struct Guard<std::shared_ptr<T>, U, op>
{
Guard(std::shared_ptr<T>& g):
_g(g){}
~Guard()
{
std::cout << "shared_ptr guard" << std::endl;
((*_g).*op)();
}
std::shared_ptr<T> _g;
};
Demo:
struct Foo
{
void bar()
{
std::cout << "Foo::bar()" << std::endl;
}
};
int main()
{
Foo foo;
{
typedef Guard<Foo, Foo, &Foo::bar> FooGuard;
FooGuard g(&foo);
}
std::shared_ptr<Foo> foo_ptr = std::make_shared<Foo>();
{
typedef Guard<std::shared_ptr<Foo>, Foo, &Foo::bar> FooGuard;
FooGuard g(foo_ptr);
}
return 0;
}
Output:
normal guard
Foo::bar()
shared_ptr guard
Foo::bar()
live example

Answer 2

I would suggest using lambda functions instead and capture by value:
#include <functional>
#include <memory>
struct Guard
{
typedef std::function<void()> func_type;
Guard( const func_type& f ): func(f) {}
~Guard() { if (func) func(); }
func_type func;
};
struct Foo
{
void bar() {}
};
int main()
{
auto foo_ptr = std::make_shared<Foo>();
Guard g([foo_ptr](){ foo_ptr->bar(); }); // note the capture by value
}
Note that you are free to capture by reference too, if you want to guard an instance allocated on the stack for example.

Answer 3

If you really want to stick to the ugly way, I would suggest using deleters:
#include <string>
#include <memory>
#include <cstdio>
template < class T, void (T::*op)() >
struct Guard
{
Guard( T *p ): ptr( p, [](T*){} ) {}
Guard( const std::shared_ptr<T>& p ): ptr(p) {}
~Guard() { if (ptr) ((*ptr).*op)(); }
std::shared_ptr<T> ptr;
};
struct Foo
{
Foo( const char* n ): name(n) {}
void bar() { printf("Hello from %s\n",name.c_str()); }
std::string name;
};
int main()
{
auto foo1 = Foo("Bob");
auto foo2 = std::make_shared<Foo>("Alice");
Guard<Foo,&Foo::bar> g1(&foo1), g2(foo2);
}