Re: why std::vector<T>&& is not a universal reference?
On 2012-10-09 15:16, Gennadiy Rozental wrote:
On Tuesday, October 9, 2012 12:30:03 AM UTC-4, Daniel Kr?gler wrote:
Am 09.10.2012 00:48, schrieb Gennadiy Rozental:
Any workarounds?
The usual technique is to specify a function of the form T&& and to
constrain it accordingly. E.g.
#include <vector>
#include <type_traits>
template<class T>
struct is_vector : std::false_type {};
template<class T>
struct is_vector<std::vector<T>> : std::true_type {};
While we on the subject, why doesn't standard type traits provide
this?
I don't think that this trait should be standardized, because it is
neither very complicated to write, nor do I see any general pattern in
it. For example:
1) Why should the Standard Library provide a traits for std::vector, if
there is none for std::deque, std::list, std::map, ...
2) Assuming you suggest: "Add these, too!" I would like to see the end
of this: It seems to me as if you were asking for traits that check
whether an arbitrary type T is any Standard Library type. This looks
unmanageable and not useful to me.
Generally useful traits provide answer to questions that are related to
type families that satisfy concepts. Concepts are not restricted to
templates, they can be applied to any types including types from
different template types. E.g. the concept of a container could contain
types that are std::vector<T>, std::list<T>, YourPerfectContainer<T>, etc...
I suggest that you start to think about the type properties that you
want to support for your forwarding function template and to build
corresponding traits that check whether a type satisfies these
compile-time requirements (as expression-constraints, associated-type
constraints, etc.). These traits can be reused for all your templates
and are very valuable. E.g. once you have realized what specifc
requirements you need, you invent this trait - lets name it
"is_sequential_container" for the moment - you would then define
template<class T>
typename std::enable_if<
is_sequential_container<T>::value,
/ReturnType/>::type
foo(T&&){ /.../ }
template<class T>
typename std::enable_if<
is_sequential_container<T>::value,
/ReturnType/>::type
bar(T&&){ /.../ }
etc...
Also is there any way to implement this without including
<vector>. It seems like we will have to include one even if my
specific use case does not require it.
Yes, if you have a direct dependency to the std::vector template, you
have no portable means but adding the header <vector>. But if you do as
I suggest above, that means: if you create your own type trait
is_sequential_container, you have no dependency to std::vector any more.
You only define it as a traits that validates assumed expressions and
member names. This can be done without adding any header for library
containers.
Here a concrete example: I once needed a trait that checks whether a
type satisfies the requirements of a CORBA sequence, because I wanted to
create a nice adapter to more modern C++ patterns (E.g for-range-support
and several other things). To implement this trait is_corba_sequence I
didn't need to include any CORBA header, because I can define the
required expressions by reading the CORBA specification, more
specifically from the standardized CORBA C++ language mapping and
therefore I can test for these expressions without any concrete
dependencies to existing templates.
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! ]