Question

Got this ScopeExit class off code-project but it would not build on GCC 4.5.3. Appreciate any help.

class ScopeExit : private boost::noncopyable
{
    typedef std::function<void()> func_t;

public:
    ScopeExit(func_t&& f) : func(f) {}
    ~ScopeExit() { func(); }

private:
    // no default ctor
    ScopeExit();

    // Prohibit construction from lvalues.
    ScopeExit(func_t&);

    // Prohibit new/delete.
    void* operator new(size_t);
    void* operator new[](size_t);
    void operator delete(void *);
    void operator delete[](void *);

    const func_t func;
};


ScopeExit exit = [&]() { };

gcc 4.5.3 errors:

In member function ‘void test()’:
error: conversion from ‘test()::<lambda()>’ to non-scalar type ‘ScopeExit’ requested

Edit:

ScopeExit exit([&]() { }); // this works

Answer 1

It’s copy/move initialization. Your copy c-tor is deleted, move c-tor is deleted too.

n3337 12.8/9

If the definition of a class X does not explicitly declare a move constructor, one will be implicitly declared
as defaulted if and only if

— X does not have a user-declared copy constructor,

— X does not have a user-declared copy assignment operator,

— X does not have a user-declared move assignment operator,

— X does not have a user-declared destructor, and

— the move constructor would not be implicitly defined as deleted.

Have no ideas why first case doesn’t work, but this case works fine

template<typename T>
ScopeExit(T&& f) : func(std::move(f)) {}
ScopeExit(ScopeExit&& rhs) : func(std::move(rhs.func)) { }]

EDIT.

When we use copy-initialization of variable of class-type only standard and elipsis implicit conversions are used. Conversion from lambda to function pointer or from function pointer to std::function is user-defined conversion and not used.

n3337 8.5/16

The semantics of initializers are as follows. The destination type is the type of the object or reference being
initialized and the source type is the type of the initializer expression. If the initializer is not a single (possibly
parenthesized) expression, the source type is not defined.

If the destination type is a (possibly cv-qualified) class type:

Otherwise (i.e., for the remaining copy-initialization cases), user-defined conversion sequences
that can convert from the source type to the destination type or (when a conversion function
is used) to a derived class thereof are enumerated as described in 13.3.1.4, and the best one is
chosen through overload resolution (13.3). If the conversion cannot be done or is ambiguous, the
initialization is ill-formed.

n3337 13.3.1.4/1

Under the conditions specified in 8.5, as part of a copy-initialization of an object of class type, a user-defined
conversion can be invoked to convert an initializer expression to the type of the object being initialized.
Overload resolution is used to select the user-defined conversion to be invoked. Assuming that “cv1 T” is
the type of the object being initialized, with T a class type, the candidate functions are selected as follows:

— The converting constructors (12.3.1) of T are candidate functions.

1. In both cases, the argument list has one argument, which is the initializer expression. [ Note: This argument
   will be compared against the first parameter of the constructors and against the implicit object parameter
   of the conversion functions. — end note ]

n3337 13.3.2

1. From the set of candidate functions constructed for a given context (13.3.1), a set of viable functions is
chosen, from which the best function will be selected by comparing argument conversion sequences for the
best fit (13.3.3). The selection of viable functions considers relationships between arguments and function
parameters other than the ranking of conversion sequences.

Second, for F to be a viable function, there shall exist for each argument an implicit conversion se-
quence (13.3.3.1) that converts that argument to the corresponding parameter of F.

n3337 13.3.3.1/4

However, when considering the argument of a constructor or user-defined conversion function that is a
candidate by 13.3.1.3 when invoked for the copying/moving of the temporary in the second step of a class
copy-initialization, by 13.3.1.7 when passing the initializer list as a single argument or when the initializer
list has exactly one element and a conversion to some class X or reference to (possibly cv-qualified) X is
considered for the first parameter of a constructor of X, or by 13.3.1.4, 13.3.1.5, or 13.3.1.6 in all cases, only
standard conversion sequences and ellipsis conversion sequences are considered.