Best style for deleting all constructors (or other function)?

c++, c++11, delete-operator, memory-management

Solution

There is a difference, for example:

#include <type_traits>

struct Unconstructible
{
    Unconstructible() = delete;
};

static_assert( !std::is_default_constructible<Unconstructible>::value, "not default constructible" );
static_assert( std::is_copy_constructible<Unconstructible>::value, "copyable" );

Although you can never construct this object, so in practice you can never create a copy of one either, according the language and the type traits in the library, it is technically CopyConstructible, because there's an implicitly-declared copy constructor.

Similarly, with the `Impossible(...)` or `Impossible(Ts&&...)` forms there is still an implicitly-declared copy constructor.

On the other hand, if you do it this way:

#include <type_traits>

struct Unconstructible
{
    Unconstructible(const Unconstructible&) = delete;
};

static_assert( !std::is_default_constructible<Unconstructible>::value, "not default constructible" );
static_assert( !std::is_copy_constructible<Unconstructible>::value, "not copyable" );

The existence of a user-declared constructor suppresses the implicit declaration of the default constructor, so the class is neither DefaultConstructible nor CopyConstructible.

N.B. your last example should probably be `Impossible(Ts&&...)` to match any types, including non-copyable and non-movable ones.

Problem

Let's say I want to make a type that cannot be constructed (don't ask why). ``` struct Impossible { ``` I could do it like this: ``` Impossible() = delete; // disable automatically generated constructors, don't declare any others Impossible(const Impossible&) = delete; // I suppose this is redundant with nothing to copy ``` or like this: ``` Impossible(...) = delete; // explicitly disable all constructors ``` or like this: ``` template<typename... Ts> Impossible(Ts...) = delete; // explicitly disable all constructors, template version }; ``` I guess I could ask the same thing about any function, not just constructors. Does it make any difference which one I choose? In terms of syntax I think I like the second option. But is there any situation, whatsoever, where it's possible to detect a difference (other than in the text of an error message)?

Original source