Boost logo

Boost :

From: Howard Hinnant (hinnant_at_[hidden])
Date: 2005-01-01 12:08:41

On Dec 22, 2004, at 8:29 AM, Thorsten Ottosen wrote:

> The following trait is supposed to make it easier to forward
> arguments in generic code and in particular string literals. For
> example, I
> will use it when I update boost.assign
> to use const T& arguments instead of T arguments. It could also be
> used to
> make a better version of std::make_pair():
> template< class F, class S >
> inline std::pair< typename decayed<F>::type,
> typename decayed<S>::type >
> make_pair( const F& f, const S& s )
> {
> return std::pair< typename decayed<F>::type,
> typename decayed<S>::type >( f, s );
> }
> Any thoughts from the type_traits authors?

I think decayed is an excellent trait. Your implementation should be
modified to also take care of functions converting into function
pointers though. It's a shame about the const qaulifier in your
example make_pair messing up the int[10] conversion to int*. But with
an eye towards the future, I think decayed will still eventually
improve make_pair:

template <class T, class U>
pair<typename decayed<typename remove_reference<T>::type>::type,
      typename decayed<typename remove_reference<U>::type>::type>
make_pair(T&& t, U&& u)
     typedef typename decayed<typename remove_reference<T>::type>::type
     typedef typename decayed<typename remove_reference<U>::type>::type
     return pair<dT, dU>(std::forward<T>(t), std::forward<U>(u));

This alternative will mimic the present (by value) make_pair, and work

     int array[10];
     std::pair<int*,int*> p5 = std::make_pair( array, array );

It will also move from rvalue arguments such as string or vector making
it more efficient (assuming a move-aware pair in the future).

decayed has my vote for a useful trait (especially assuming an rvalue

On Jan 1, 2005, at 10:40 AM, Pavel Vozenilek wrote:

> - following compiles:
> struct ABC {
> explicit ABC(int) {}
> };
> std::pair<ABC, ABC> p5 = boost::make_pair(1, 2);
> std::pair<ABC, ABC> p5 = std::make_pair(1, 2); // also compiles
> Maybe the boost::make_pair could be coded
> somehow to disable this behavior (ABC constructor
> is explicit).

This is a characteristic of pair, not make_pair. And it could be
disabled by restricting the member template constructor in:

template <class T1, class T2>
struct pair {
   typedef T1 first_type;
   typedef T2 second_type;

   T1 first;
   T2 second;
   pair(const T1& x, const T2& y);
   template<class U, class V> pair(const pair<U, V> &p);

such that is_convertible<U, T1> and is_convertible<V, T2>, which is a
change I would support.


Boost list run by bdawes at, gregod at, cpdaniel at, john at