I have this code:

void normal_func(int p)
{
    _tprintf_s(_T("p: %d\n"), p);
}

struct normal_struct_func
{
    inline void operator()(int p) const
    {
        _tprintf_s(_T("p: %d\n"), p);
    }
};

template<typename T, typename Function>
void test_f(T p, Function func)
{
    func(p);
}

template<typename T, typename Function>
class test_c {
public:
    explicit test_c(T p, Function func) : m_p(p), m_Func(func) {}

    ~test_c(void)
    {
        m_Func(m_p);
    }

    T get(void) const
    {
        return m_p;
    }

private:
    T m_p;
    const Function m_Func;
};

int _tmain(int argc, _TCHAR* argv[])
{
    // test_f tests
    test_f(11, [](int p){_tprintf_s(_T("p: %d\n"), p);});
    test_f(22, normal_func);
    test_f(33, normal_struct_func());
    
    // test_c tests
    // error C2976: 'test_c' : too few template arguments
    //test_c<int> tc1(11, [](int p){_tprintf_s(_T("p: %d\n"), p);});
    //test_c<int> tc2(22, normal_func);
    //test_c<int> tc3(33, normal_struct_func());

    // error C2664: 'test_c<T,Function>::test_c(T,Function (__cdecl *))' : cannot convert parameter 2 from '`anonymous-namespace'::<lambda1>' to 'void (__cdecl *)(int)'
    // ...
    test_c<int, void(int)> tc1(11, [](int p){_tprintf_s(_T("p: %d\n"), p);});
    test_c<int, void(int)> tc2(22, normal_func);
    test_c<int, void(int)> tc3(33, normal_struct_func());

    return 0;
}

The 'test_f' works as it should but test_c class, which does the same basically, does not.

Problem list:

1. How to make this compile. What am i missing / doing wrong.

2. Why do i have to type "test_c<int, void(int)>" instead of just "test_c<int>", the compiler should be able to figure that out, it did that for "test_f"

Thanks for your help.

Why do i have to type "test_c<int, void(int)>" instead of just "test_c<int>"

It works for test_f due to "template argument deduction". This applies only to template functions, not to template classes.

How to make this compile. What am i missing / doing wrong.

Don't use void(int). That simply means a function that takes an int and returns nothing. normal_struct_func is not a function, it's an object that has a () operator aka function object, functor etc. You could use std::function (make sure you include <functional>):

test_c<int, std::function<void(int)>> tc3(33, normal_struct_func());

2:
scoped<int*> ptr(new int, [](int *p){delete p;})
3:
scoped<int[]> ptr(new int[100], [](int *p){delete [] p;})
4:

scoped<int> ptr(1974, [](int p){ cout << p << endl;})

stuff like that.
I know of unique_ptr but i wanted to create a single template class that could do all of the above.

The class was all good with pointers and arrays but when i tried to make it do stuff like example 1 i hit a brick wall because i want it to work with all functor, see "test_f tests" for example.

It seems to be very tricky to get it to work.
One of the things i would like to minimize is the amount of typing required but the "template argument deduction" not for template classes rule, is in the way of that. auto keyword does n't help either.

Input, ideas, etc. are much appreciated.

template<typename T> 
class test_c {
public:    
    explicit test_c(T p, std::function<void(T)> func) 
        : m_p(p), m_Func(func) {
    }     
    
    ~test_c(void) {        
        m_Func(m_p);
    }
    
    T get(void) const {        
        return m_p;
    }

private:    
    T m_p;
    const std::function<void(T)> m_Func;
}; 

#include <iostream>
#include <memory>
#include <functional>

#include <windows.h>

using namespace std;

//=========================================================

/*
// Dexter's code:
template<typename T>  
class test_c { 
public:  
    explicit test_c(T p, std::function<void(T)> func)  
        : m_p(p), m_Func(func) { 
    }      
      
    ~test_c(void) {         
        m_Func(m_p); 
    } 
      
    T get(void) const {         
        return m_p; 
    } 
  
private:     
    T m_p; 
    const std::function<void(T)> m_Func; 
};
*/

// A dumbed-down version of the functors presented around
// page 110 of Modern C++ Design by Andrei Alexandrescu:
template < typename RESULT_TYPE, typename PARAMETER_TYPE >
class functor_base_t {
    public:
        virtual ~functor_base_t () {
            //
        }
        virtual RESULT_TYPE operator () ( PARAMETER_TYPE ) = 0;
};

template < typename RESULT_TYPE, typename PARAMETER_TYPE, typename FUNCTOR >
class functor_handler_t : public functor_base_t< RESULT_TYPE, PARAMETER_TYPE > {
    FUNCTOR m_functor;
    public:
        functor_handler_t ( FUNCTOR functor ) : m_functor( functor ) {
            //
        }
        virtual ~functor_handler_t () {
            //
        }
        virtual RESULT_TYPE operator () ( PARAMETER_TYPE parameter ) {
            return m_functor( parameter );
        }
};

template < typename TYPE >
class test_c {
    private:
        typedef void RESULT_TYPE;
        typedef TYPE PARAMETER_TYPE;

        PARAMETER_TYPE m_parameter;
        std::shared_ptr< functor_base_t< RESULT_TYPE, PARAMETER_TYPE > > m_functor_handler;
    public:
        template < typename FUNCTOR >
        explicit test_c ( PARAMETER_TYPE parameter, FUNCTOR functor ) :
            m_parameter( parameter ),
            m_functor_handler(
                new functor_handler_t<
                    RESULT_TYPE,
                    PARAMETER_TYPE,
                    FUNCTOR
                >( functor )
            )
        {
            //
        }
        ~test_c () {
            ( *m_functor_handler )( m_parameter );
        }
        PARAMETER_TYPE const & get () const {
            return m_parameter;
        }
};

//=========================================================

inline void normal_func ( int p ) {
    cout << "p: " << p << endl;
}

struct normal_struct_func {
    inline void operator() (int p) const {
        cout << "p: " << p << endl;
    }
};

template< typename T, typename Function >
inline void test_f ( T p, Function func ) {
    func( p );
}

int main () {
    // test_f tests
    test_f( 11, [] ( int p ) { cout << "p: " << p << endl; } );
    test_f( 22, normal_func );
    test_f( 33, normal_struct_func() );

    // test_c tests
    test_c< int > tc1( 11, [] ( int p ) { cout << "p: " << p << endl; } );
    test_c< int > tc2( 22, normal_func );
    test_c< int > tc3( 33, normal_struct_func() );

    test_c< int * > tc4(
        new int,
        [] ( int * ptr ) {
            cout << "tc4: " << *ptr << endl;
            delete ptr;
        }
    );
    *tc4.get() = 44;
    test_c< int * > tc5(
        new int[ 3 ],
        [] ( int * arr ) {
            int const * i = &arr[ 0 ];
            int const * end = &arr[ 3 ];
            cout << "tc5: { ";
            if ( i != end ) {
                cout << *i;
                for ( ++i ; i != end; ++i )
                    cout << ", " << *i;
            }
            cout << " }" << endl;
            delete[] arr;
        }
    );
    tc5.get()[ 0 ] = 55;
    tc5.get()[ 1 ] = 56;
    tc5.get()[ 2 ] = 57;

#define scoped test_c

    // 1:
    scoped<HMODULE> dll(LoadLibraryA("kernel32.dll"), [](HMODULE h){FreeLibrary(h);});

    // 2:
    scoped<int*> ptr2(new int, [](int *p){delete p;});

    // 3:
    scoped<int*> ptr3(new int[100], [](int *p){delete[] p;});

    // 4:
    scoped<int> ptr4(1974, [](int p){ cout << p << endl;});

    return 0;
}

g++ -o main.exe main.cpp -std=c++0x -march=native -O3 -Wall -Wextra -Werror

p: 11
p: 22
p: 33
1974
tc5: { 55, 56, 57 }
tc4: 44
p: 33
p: 22
p: 11

Hope This Also Helps,
Joshua Burkholder

m_onLeaveScope_empty(default_empty<T>()) 

It worked in the case of the func argument because you never use the default value in your tests. As soon as you write something like scoped<int, decltype(f)> f23(23); you'll get the same error. 

Anyway, it still won't work. Once you fix this you'll get another error: '`anonymous-namespace'::<lambda1>::(const `anonymous-namespace'::<lambda1> &)' : cannot convert parameter 1 from 'default_empty<T>' to 'const `anonymous-namespace'::<lambda1> &'

Again, you're mixing up things that look like functions but they have different types. In the particular case that triggered the above error your deleter is a lambda and the default_empty is a function object. They're not compatible.

I knew i forgot to mention something, it was 3 am when i wrote that, sorry about that.

I did get that error too, which made me confused and got me thinking i've forgot some c++ rule again.

> Again, you're mixing up things that look like functions but they have different types.

Yes, can you explain what i'm missing, please ?

How would i make it work or is that not a possibility without std::function ?

Yes, can you explain what i'm missing, please ?

Let's take the case of make_scoped(new int(1975), normal_struct_fp()). This creates a scoped<int, normal_struct_fp> where m_onLeaveScope_empty is of type normal_struct_fp. And the scoped constructor is trying to assign an object of type default_empty<int> to a variable of type normal_struct_fp. That won't work, just because 2 types have an () operator with the same signature it doesn't mean that you can convert from one type to another.

How would i make it work or is that not a possibility without std::function?

Well, it seems to me that the only purpose of m_onLeaveScope_empty is to support the move constructor. You could leave the old m_onLeaveScope alone and add a null check in the scoped destructor so the old m_onLeaveScope doesn't get called.

53 minutes ago, Dexter wrote

Well, it seems to me that the only purpose of m_onLeaveScope_empty is to support the move constructor. You could leave the old m_onLeaveScope alone and add a null check in the scoped destructor so the old m_onLeaveScope doesn't get called.

Yes, I've thought of that, it would work for the pointer version, but not for the non pointer version.

We can't really test for m_obj != 0 since 0 might be a totally valid value.

The possible solution would be to add a bool that gets set to true (is_empty = true) when the data is moved.

This, i'm guessing, would also be faster then calling an empty function.

But i'm not sure which way to go. I want it to be correct and as performance as possible so i'm still wondering if there is some kind of  template magic to sole this.

But i'm leaning to the bool solution or perhaps i should use std::function...

Am i overthinking it ?

Performance wise I'd say that the bool variant is the fastest. std::function is cleaner but it has larger time & space overhead. But you know what they say, premature optimization is the root of all evil. Things like CreateFile or LoadLibrary will take far more time to complete than the few instructions that are need by make_scope/scoped.

If you really want it to be fast then the first thing you'll want to do is to get rid of make_scoped, it's not "free".

Like this little code example:

inline void normal_function(int v) {
    cout << "normal_function: " << v << endl;
}

template <typename Function>
class sop {
    Function f_;
public:
    sop(Function fun) : f_(fun) {}
    ~sop() {
        f_();
    }
};

void t_sop()
{
    auto l = [](){
        normal_function(123);
    };
    sop<decltype(l)> s(l);
}

int main()
{
    t_sop();
    return 0;
}

Generated code in win32 release mode:

    t_sop();
00291000  mov         eax,dword ptr [__imp_std::endl (292044h)]  
00291005  mov         ecx,dword ptr [__imp_std::cout (292068h)]  
0029100B  push        eax  
0029100C  push        7Bh  
0029100E  push        offset string "normal_function: " (292114h)  
00291013  push        ecx  
00291014  call        std::operator<<<std::char_traits<char> > (2910F0h)  
00291019  add         esp,8  
0029101C  mov         ecx,eax  
0029101E  call        dword ptr [__imp_std::basic_ostream<char,std::char_traits<char> >::operator<< (292050h)]  
00291024  mov         ecx,eax  
00291026  call        dword ptr [__imp_std::basic_ostream<char,std::char_traits<char> >::operator<< (29204Ch)]  

Shouldn't you be able to achieve this with the power of c++0x but without this big overhead ?

Best would be if you could make the optimizer inline , etc..

I don't understand... that's exactly what the compiler did. The code in main is the code from normal_function, 3 calls to the stream insertion operator and nothing else.

Both your code and Burkholder's code have a big overhead.
Is there a way to minimize the overhead like in my example ? 

It seems to me that if you don't provide the function type in the template argument list (like in the original code or in your code) then the only alternative is to use std::function or something that does something similar: wraps a callable object. And this wrapping is complex because there are different types of callable objects: pointer to function, pointer to member, functors.

here an except of the code (how to register a function to call)

template <typename TEvent, typename TListener >
void _registerListener (const TListener& function) {
static_assert(!std::is_array<TEvent>::value, "You cannot register an array as an event type");
static_assert(std::is_convertible<TListener,std::function<void(TEvent&)>>::value, "Unvalid callback for this event type");
_listeners.insert(std::make_pair(&typeid(std::decay<TEvent>::type), [=](void* ev) { function(*static_cast<TEvent*>(ev)); }));
}

is_convertible and decay seens what you are looking for deal with functors, function and lambdas. There are other interesting stuff on the blog. (I think I see an example with std::bind for additional "magic"call somewhere, I'll try re-digg it)

Somebody from the c++ group should really comment on this.

Was that what you were asking ? You're question is vague, can you rephrase the question ?

I absolutely love c++ but it do have it's flaws like this one which i think is one of those things that have been overlooked.

http://pizer.wordpress.com/2008/11/22/scope-guards-revisited-c0x-style/#more-188

Arr where's that vs2011 beta ?!

std::function encapsulates that machinery. It inherently has nonzero cost, and inherently must throw exceptions for arbitrarily large functors.

There is no flaw to solve here.

Take this code and compile it in release mode / win32 and look at it in debugging.

#include <iostream>
#include <functional>

using namespace std;

inline void func() {
    cout << "func" << endl;
}

struct s_func {
    inline void operator()() {
        cout << "s_func" << endl;
    }
};

template <typename Functor>
void test_template(Functor f) {
    f();
}

void test_function(function<void()> f) {
    f();
}

int main()
{
    test_template(func);
    test_function(func);

    test_template(s_func());
    test_function(s_func());
}

test_template(func):

    test_template(func);
00301095  mov         eax,dword ptr [__imp_std::endl (302044h)]  
0030109A  mov         ecx,dword ptr [__imp_std::cout (302068h)]  
003010A0  push        eax  
003010A1  push        offset string "func" (30214Ch)  
003010A6  push        ecx  
003010A7  call        std::operator<<<std::char_traits<char> > (301240h)  
003010AC  add         esp,8  
003010AF  mov         ecx,eax  
003010B1  call        dword ptr [__imp_std::basic_ostream<char,std::char_traits<char> >::operator<< (30204Ch)]  

test_function(func); : (called functions not included)

    test_function(func);
003010B7  mov         edx,offset func (301040h)  
003010BC  test        edx,edx  
003010BE  jne         main+54h (3010C4h)  
003010C0  xor         ecx,ecx  
003010C2  jmp         main+65h (3010D5h)  
003010C4  mov         dword ptr [ebp-24h],offset std::tr1::_Impl_no_alloc0<std::tr1::_Callable_fun<void (__cdecl*const)(void),0>,void>::`vftable' (302188h)  
003010CB  mov         dword ptr [ebp-20h],offset func (301040h)  
003010D2  lea         ecx,[ebp-24h]  
003010D5  mov         dword ptr [ebp-14h],ecx  
003010D8  mov         dword ptr [ebp-4],0  
003010DF  test        ecx,ecx  
003010E1  jne         $LN163 (3010E9h)  
003010E3  call        dword ptr [__imp_std::tr1::_Xfunc (302064h)]  
$LN163:
003010E9  mov         eax,dword ptr [ecx]  
003010EB  mov         edx,dword ptr [eax+4]  
003010EE  call        edx  
003010F0  mov         dword ptr [ebp-4],0FFFFFFFFh  
003010F7  mov         ecx,dword ptr [ebp-14h]  
003010FA  test        ecx,ecx  
003010FC  je          $LN163+28h (301111h)  
003010FE  mov         eax,dword ptr [ecx]  
00301100  mov         eax,dword ptr [eax+0Ch]  
00301103  lea         edx,[ebp-24h]  
00301106  cmp         ecx,edx  
00301108  setne       dl  
0030110B  movzx       edx,dl  
0030110E  push        edx  
0030110F  call        eax  

function 'test_template' is a clear winner. Now the sad part is that you can't do this in a class without overhead because you have to store the function object which isn't really supported so you have to resort to tricks which have overhead.

// class version equivalent to test_template
// This should have been supported but nope
class scope_guard {
    auto f;
public:
    template <typename Functor>
    scope_guard(Functor f_obj) : f(f_obj) { // <- ???
    }
    ~scope_guard() {
        f();
    }

function "test_template" works because you don't have to store the function object

template<typename Functor>
class scope_guard
{
public:
    explicit scope_guard(Functor &f) throw()
        : _f(std::addressof(f)) 
    { 
    }

    ~scope_guard() throw()
    {
        if( _f != nullptr )
        {
            try
            {
                (*_f)();
            }
            catch(...)
            {
                std::terminate();
            }
        }
    }

    scope_guard(scope_guard<Functor> &&other) throw()
        : _f(other._f)
    {
        other._f = nullptr;
    }

    scope_guard<Functor>& operator=(scope_guard<Functor> &&other) throw()
    {
        if( &other != this )
        {
            _f = other._f;
            other._f == nullptr;
        }
        return *this;
    }
private:
    scope_guard(const scope_guard<Functor>&);
    scope_guard<Functor>& operator=(const scope_guard<Functor>&);

    Functor *_f;
};

template<typename Functor>
inline scope_guard<Functor> create_scope_guard(Functor &f) throw()
{
    return scope_guard<Functor>(f);
}

This makes the scope_guard non-copyable but movable, so it can be returned by value without triggering the action of desctructor more than once. This allows the create_scope_guard function to do the template parameter deduction for you.

Use as:

auto guard = create_scope_guard([]() { cout << "foo" << endl; });

It's not entirely your syntax, but it's not too bad, I think.

It's essentially like STL's class but using a move constructor and a function in place of the macro.

Note that due to the behavior of copy elision in VC++ the move constructor isn't strictly necessary. VC++ lets you return a non-copyable object by value if it can perform copy elision. By contrast, g++ will not allow you to return an object by value without a public copy or move constructor, even if neither would be called due to copy elision.

I remember doing something similar. The problem was the same as in your suggestion.

It doesn't work for plain functions, in your case it because of "std::addressof".

I remember trying to use some template magic, traits, is_function<..>, conditional, enable_if,  to make the compiler choose between two version but i failed miserably.

The compiler just didn't want to play ball. Either it's due to bugs in the compiler or me missing some small detail.

I just could figure out why it didn't work. Not even g++'s more helpful error messages helped me.

About 'Mr Crash' auto in class pseudo code: Would have been sweet if auto worked in classes like that. It would have reduced the pain of some template programming though it would surely cause other problems.

template<typename Functor>
class scope_guard {
public:
    explicit scope_guard(Functor &f, false_type) throw()
        : _f(addressof(f))
    {}

    explicit scope_guard(Functor &f, true_type) throw()
        : _f(f)
    {}

    ~scope_guard() throw()

    {
        if( _f != nullptr )
        {
            try
            {
                (*_f)();
            }
            catch(...)
            {
                std::terminate();
            }
        }
    }

    scope_guard(scope_guard<Functor> &&other) throw()
        : _f(other._f)
    {
        other._f = nullptr;
    }

    scope_guard<Functor>& operator=(scope_guard<Functor> &&other) throw()
    {
        if( &other != this )
        {
            _f = other._f;
            other._f == nullptr;
        }
        return *this;
    }
private:
    scope_guard(const scope_guard<Functor>&);
    scope_guard<Functor>& operator=(const scope_guard<Functor>&);

    Functor *_f;
};

template<typename Functor>
inline scope_guard<Functor> create_scope_guard(Functor &f) throw()
{
    return scope_guard<Functor>(f, typename is_function<Functor>::type());
}

inline void noarg_func( void ) {
    cout << "noarg_func" << endl;
}
struct noarg_functor {
    inline void operator()( void ) const {
        cout << "noarg_functor" << endl;
    }
};

void test() {
    auto guard1 = create_scope_guard([](){cout << "noarg_lambda" << endl;});
    auto guard2 = create_scope_guard(noarg_functor());
    auto guard3 = create_scope_guard(noarg_func); // <- Doesn't get inlined
}

int main()
{
    test();
}

Only problem is that this class use of " C4239: nonstandard extension used ..."
which is very bad 

I came up with this, which uses an enable_if selected template function to pick how to get the address of the function.

template<typename Functor>
class scope_guard
{
public:
    scope_guard(Functor &f) throw()
        : _f(addressof(f)) 
    {
    }

    ~scope_guard() throw()
    {
        if( _f != nullptr )
        {
            try
            {
                (*_f)();
            }
            catch(...)
            {
                std::terminate();
            }
        }
    }

    scope_guard(scope_guard<Functor> &&other) throw()
        : _f(other._f)
    {
        other._f = nullptr;
    }

    scope_guard<Functor>& operator=(scope_guard<Functor> &&other) throw()
    {
        if( &other != this )
        {
            _f = other._f;
            other._f == nullptr;
        }
        return *this;
    }
private:
    template<typename T>
    static typename std::enable_if<std::is_function<T>::value, T*>::type addressof(T &value)
    {
        return &value;
    }

    template<typename T>
    static typename std::enable_if<!std::is_function<T>::value, T*>::type addressof(T &value)
    {
        return std::addressof(value);
    }

    scope_guard(const scope_guard<Functor>&);
    scope_guard<Functor>& operator=(const scope_guard<Functor>&);

    Functor *_f;
};

template<typename Functor>
inline scope_guard<Functor> create_scope_guard(Functor &f) throw()
{
    return scope_guard<Functor>(f);
}

It works in VC++, but g++ is being more difficult, particularly because it doesn't support std::addressof, but also because it can't bind a lambda to a non-const reference parameter.

template<typename Functor>
inline scope_guard<Functor> create_scope_guard(const Functor &f) throw()
{
    return scope_guard<Functor>(const_cast<Functor&>(f));
}

C:\test>g++ -Wall -Wextra -std=c++0x -o main.exe test.cpp
test.cpp: In function 'scope_guard<Functor> create_scope_guard(const Functor&) [with Functor = void()]':
test.cpp:100:45:   instantiated from here
test.cpp:85:53: error: invalid use of const_cast with type 'void (&)()', which is a pointer or reference to a function type
test.cpp:86:1: warning: control reaches end of non-void function

Both my version and STL's version are initialized using a non-const reference, which should not be able to bind to an rvalue. According to N3242, the result of a lambda expression is a pure rvalue, so you should not be able to call that constructor (or the create_scope_guard) using a lambda. STL's macro gets around that by storing the lambda in a local variable first, so he's not passing an rvalue to the function.

And come to think of it, using "create_scope_guard(noarg_functor());" shouldn't work either, because a temporary shouldn't bind to an non-const reference either. What's worse, I'm storing the address of that temporary, which is destructed as soon as create_scope_guard returns, so when the scope_guard goes out of scope it will try to use an already destructed object! Again, this doesn't apply to STL's version because if you use the macro, you're never passing a functor to it.

I find it very peculiar that VC++ lets you bind rvalue temporaries to non-const references, even though the standard explicitly forbids that, even in C++03.

Despite circumventing this issue (as long as you use the macro), STL's ScopeWarden class still won't work in g++ of course, due to the use of std::addressof (not yet supported) and __declspec(nothrow) (not standard).

Therefore, I believe the only way to make this safe to use on function pointers, functors and lambdas is to copy the function object by value. Yes, this may be problematic if the functor is large or has a non-trivial copy ctor, but I don't think there's another safe, standards-compliant way to do this.

The following uses this approach, and works in VC2010 and g++ 4.5:

template<typename Functor>
class scope_guard
{
public:
    scope_guard(Functor function)
        : _function(function), _valid(true)
    {
    }

    ~scope_guard() throw()
    {
        if( _valid )
        {
            try
            {
                _function();
            }
            catch(...)
            {
                std::terminate();
            }
        }
    }

    scope_guard(scope_guard<Functor> &&other)
        : _function(std::move(other._function)), _valid(other._valid)
    {
        other._valid = false;
    }

    scope_guard<Functor>& operator=(scope_guard<Functor> &&other)
    {
        if( &other != this )
        {
            _function = std::move(other._function);
            _valid = other._valid;
            other._valid = false;
        }
        return *this;
    }
private:
    scope_guard(const scope_guard<Functor>&);
    scope_guard<Functor>& operator=(const scope_guard<Functor>&);

    Functor _function;
    bool _valid;
};

template<typename Functor>
inline scope_guard<Functor> create_scope_guard(Functor function)
{
    return scope_guard<Functor>(function);
}

Yep, ScopeWarden is designed to invoke named functors (including named lambdas). The macro is just for convenience.

Because ScopeWarden is templated on functor type, it's physically impossible to give it an unnamed lambda.

Finally, observe that "explicit ScopeWarden(F&&);" is private and unimplemented. That prevents you, at compile-time, from constructing ScopeWarden<F> from an F rvalue.

(I am *very* careful.)

> I find it very peculiar that VC++ lets you bind rvalue temporaries to non-const references, even though the standard explicitly forbids that, even in C++03.

This is what I refer to as the Evil Extension. Always compile with /W4, which usually warns about any attempt to invoke the Evil Extension.

> Despite circumventing this issue (as long as you use the macro), STL's ScopeWarden
> class still won't work in g++ of course, due to the use of
> std::addressof (not yet supported)

Just say "&f". std::addressof() was for pedantic correctness, if someone has a functor that also overloads the address-of operator.

> and __declspec(nothrow) (not standard).

Just eliminate it - it's an optimization hint - or replace it with noexcept (GCC 4.6+). With noexcept, you don't need the try-catch-terminate in the dtor.

ScopeWarden is perfectly portable, I just didn't bother to write the minor ifdefs to make it so.

By the way - the problem with copying by value is that copy ctors can throw exceptions (what if the functor contains a std::string?). Consider what happens if you write:

do_X();

[... scope guard g to undo X, whose construction can throw ...]

do_Y();

g.dismiss();

If g's construction (or anything involved in it, like a helper function) throws, then X will remain done without Y being done.  That violates transaction semantics, and defeats the whole purpose of a scope guard.

By the way - the problem with copying by value is that copy ctors can throw exceptions

I realize that, but so can constructors. If I use your ScopeWarden like this:

SomeFunctor f;ScopeWarden<SomeFunctor> warden(f);

The constructor for f can still throw an exception, even if the ScopeWarden cannot. Is there any strong guarantee in the standard that construction of a lambda won't throw an exception?

Personally, if I were to use a class like this for transaction semantics, I'd probably use it like this:

SCOPE_WARDEN(if( isXDone ) UndoX(););DoX();

This circumvents the whole issue of throwing exceptions in the ctor.

This is similar to how C#'s using puts the variable outside the generated try/finally block, but its instantiation inside, and then in the finally block it checks for null before calling Dispose.

Ultimately the question here is: how would you define your ScopeWarden to be usablewithout a macro, but still require only a single statement to use and not require explicitly stating the template parameter? That's what I've been trying to do (more as a thought exercise rather than for anything practical), and what I think Jonas_No's goal was too.

Are you saying &func? That's an rvalue (observe that &(&func) would be bogus).

ScopeWarden could be partially specialized for function pointers (it's just obnoxious if you want to handle arbitrary calling conventions).

> The constructor for f can still throw an exception, even if the ScopeWarden cannot.

Yeah, ScopeWarden can't defend against that. "Don't do that then."

> Is there any strong guarantee in the standard that construction of a lambda won't throw an exception?

Lambdas with value captures of throwing types obviously can. The Standard appears to be silent about stateless lambdas, and lambdas with only value captures of non-throwing types (e.g. int) and reference captures, but no sane implementation will ever emit exceptions for those.

> Personally, if I were to use a class like this for transaction semantics, I'd probably use it like this:
> SCOPE_WARDEN(if( isXDone ) UndoX();DoX();

Ah, but then X needs to record that it's done.

> This circumvents the whole issue of throwing exceptions in the ctor.

The SCOPE_WARDEN macro already avoids that.

> Ultimately the question here is: how would you define your ScopeWarden to be usablewithout
> a macro, but still require only a single statement to use and not require explicitly
> stating the template parameter? That's what I've been trying to do (more as a thought
> exercise rather than for anything practical), and what I think Jonas_No's goal was too.

I don't think it can be done, and I thought about this for a long time while writing ScopeWarden.

6 hours ago,STL wrote

 Are you saying &func? That's an rvalue (observe that &(&func) would be bogus).

No, I'm doing the following:

template<typename Functor>class TestClass{public:    TestClass(Functor &f) : _f(&f) { }private:    TestClass(Functor &&); // (*)    Functor *_f;};template<typename Functor>inline TestClass<Functor> Create(Functor &f){    return TestClass<Functor>(f);}void Foo(){}int main(){    auto test = Create(Foo);    return 0;}

This gives the error message "error C2248: 'TestClass<Functor>::TestClass' : cannot access private member declared in class 'TestClass<Functor>'".

But if you remove the line marked with (*), it works fine.

I don't think it can be done, and I thought about this for a long time while writing ScopeWarden.

I expect you're right, at least without accepting the use of the copy ctor. Of course, you could simply mandate "don't use types that can throw in the copy ctor" and be done with it.

That is still sad to hear.