Re: Determining whether type is assignable
Am 19.11.2010 21:02, schrieb Adam Badura:
Is there any way to detect for given two types whether one is
assignable to the other. To be more specific having types "To" and
"From" I want to know whether "t = f" is a valid code for "t" being
"To&" and "f" being "const From&".
Yes. The paper
http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3142.html
has recently been accepted during the Batavia meeting and gives a hint
how this can be implemented (see [1] below for an example).
Most typically you will want to use std::is_copy_assignable<T>, which
has exactly the above described semantics when From and To are the same.
Use std::is_assignable<T, U>, if you want have control over
type-variation and lvalue-ness. In this case you need to specify the
references during the test, e.g.
std::is_assignable<To&, const From&>
This trait does intentionally allow to test for more general assignment
situations, e.g. it can express proxy-semantics of assignment as
provided by slice_array:
const slice_array& operator=(const slice_array&) const;
void operator=(const T&) const;
Check the earlier paper
http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2009/n2819.html
for some other special assignment proxies in the standard library.
It would be ideal if I could know whether this is valid at
specified access level, but any access level is fine too. And I guess
there is no way of doing it for access other than public as I haven't
seen anything like this before.
Yes, the new traits are specified to check for public access. The more
precise wording used here is "as if in a context unrelated to T and U".
But you cannot do that by your own portable code.
Also detecting assignment within same type (where "To" and "From"
are the same type) would be fine too.
This is automatically provided by the convenience traits
std::is_copy_assignable<T>
std::is_move_assignable<T>
They are easy to implement once you have is_assignable.
The solution may use new language features implemented in Visual
Studio 2010.
If you want to roll your own, use decltype and declval as shown in the
paper, see below at the end of this message. I'm not sure whether both
are already provided in VS 2010 yet. Such a hand-rolled version can
of-course not provide access-checking for you, because that cannot be
done within normal language tools.
I was looking for something like this in Boost or STD but found
nothing. Which made me think it cannot be done at all.
It can be done (except access checking) with decltype and declval.
I made few tries to do it myself but my solutions didn't work with
classes having non-public assignment operators (it claimed the
assignment is allowed while it is actually inaccessible). Also I had
problems when the class derived from boost::noncopyable and this was
the worst case as it lead to compilation error.
Sorry, any form of access-checking is out-of-scope for a hand-rolled
version, you need std::is_assignable for this.
HTH & Greetings from Bremen,
Daniel Kr?gler
[1] Example implementation for is_assignable, is_copy_assignable, and
is_move_assignable. At the end you find also an implementation for
declval (but omitting noexcept), if your compiler does not provide it yet.
#include <utility>
#include <type_traits>
namespace details {
struct is_assignable_checker {
template <class T, class U,
class = decltype(std::declval<T>() = std::declval<U>())
>
static std::true_type test(int);
template <class, class>
static std::false_type test(...);
};
template<class T, class U>
struct is_assignable_impl {
typedef decltype(is_assignable_checker::test<T, U>(0)) result;
};
}
template <class T, class U>
struct is_assignable : details::is_assignable_impl<T, U>::result {};
template <class T>
struct is_copy_assignable : is_assignable<T&, const T&> {};
template <class T>
struct is_move_assignable : is_assignable<T&, T&&> {};
------------------------------------
template<class T>
struct declval_protector {
static const bool stop = false;
static typename std::add_rvalue_reference<T>::type delegate(); //
undefined
};
template<class T>
typename std::add_rvalue_reference<T>::type declval() {
static_assert(declval_protector<T>::stop, "declval() must not be
odr-used!");
return declval_protector<T>::delegate();
}
--
[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]