Re: How to conditionally disable a copy constructor?
Am 22.11.2011 20:44, schrieb Andrzej Krzemie??ski:
I am trying to implement a template "wrapper" for any arbitrary type,
much like boost::optional. In fact I am trying to write my own
alternative implementation of optional. I want it to have the
following property: if the wrapped type T ptovides copy constructor,
optional<T> also provides a copy constructor; similarly, optional<T>
provides a move constructor iff T provides one. With concepts (as
defined in N2914), I would express it like this:
template< typename T>
struct Optional
{
requires CopyConstructible<T>
Optional( Optional const& );
requires MoveConstructible<T>
Optional( Optional&& );
};
Note that even with concepts these constrained member functions would
not have changed the actual copy-constructor into a "constrained special
member function", see 9.2 p19:
"A constrained member is treated as a constrained template (14.11)
whose template requirements include the requirements specified in its
member-requirement clause and the requirements of each enclosing
constrained template."
This has the effect that 12.8, especially footnote 113:
"Because a template constructor or a constructor whose first parameter
is an rvalue reference is never a copy constructor, the presence of such
a constructor does not suppress the implicit declaration of a copy
constructor. Such constructors participate in overload resolution with
other constructors, including copy constructors, and, if selected, will
be used to copy an object."
was still in effect and thus would not have prevented the copy/move
constructor to be declared.
Do you know of any way to implement similar behavior in C++11? The
enable_if trick does not seem to work for disabling the default
constructor.
I assume here, that instead of the "default constructor" you actually
mean the "implicitly-declared copy/move constructor" (otherwise I
wouldn't understand your previous comment about constrained member
functions).
If I correctly understand you, Optional does not contain a member or
base of type T (otherwise the compiler-declared constructors would
already work as intended), instead you have some opaque buffer for the
to be constructed T. In this case, I suggest the following approach
(ignoring the copy/move assignment operations for the moment):
Invent the following empty types:
struct copy_move1 {};
struct copy_move2 {};
struct move_no_copy {
move_no_copy(const move_no_copy&) = delete;
move_no_copy(move_no_copy&&) = default;
};
struct copy_no_move {
copy_no_move(const copy_no_move&) = default;
copy_no_move(copy_no_move&&) = delete;
};
Define a so-called TransformationTrait (see 20.9.1), name it copy_base,
that has a single template parameter T and that defines a member type
"type" such that
if std::is_copy_constructible<T>::value == true then type is equal to
copy_move1, else type is equal to move_no_copy.
This can easily be realized via std::conditional:
template<class T>
struct copy_base : std::conditional<
std::is_copy_constructible<T>::value,
copy_move1, move_no_copy>
{};
Define a second TransformationTrait, name it move_base, that has a
single template parameter T and that defines a member type "type" such that
if std::is_move_constructible<T>::value == true then type is equal to
copy_move2, else type is equal to copy_no_move.
Once you have done so, you start defining Optional like so:
template< typename T >
struct Optional : private copy_base<T>::type,
private move_base<T>::type
{
};
The effects should be as if you had a member (or base class) that has
the same copy/move behaviour as T.
Does this answer your question?
HTH & Greetings from Bremen,
Daniel Kr??gler
--
[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]