220 6752 <79b31f45-f3dc-4bc8-bc1e-8f33e7c190e8@isocpp.org> article Path: news.gmane.org!not-for-mail From: Vlad from Moscow Newsgroups: gmane.comp.lang.c++.isocpp.proposals Subject: Re: pair_iterator Date: Sat, 28 Sep 2013 21:54:03 -0700 (PDT) Lines: 454 Approved: news@gmane.org Message-ID: <79b31f45-f3dc-4bc8-bc1e-8f33e7c190e8@isocpp.org> References: <7498d5e4-4933-4890-854c-9bf998268cc1@isocpp.org> <70662a4d-21e1-4705-bb69-e99dfde5ee90@isocpp.org> Reply-To: std-proposals@isocpp.org NNTP-Posting-Host: plane.gmane.org Mime-Version: 1.0 Content-Type: multipart/alternative; boundary="----=_Part_1278_6319418.1380430443838" X-Trace: ger.gmane.org 1380430445 18541 80.91.229.3 (29 Sep 2013 04:54:05 GMT) X-Complaints-To: usenet@ger.gmane.org NNTP-Posting-Date: Sun, 29 Sep 2013 04:54:05 +0000 (UTC) To: std-proposals@isocpp.org Original-X-From: std-proposals+bncBCXLLRHD7IDRB3PET2JAKGQEGJNDVOI@isocpp.org Sun Sep 29 06:54:09 2013 Return-path: Envelope-to: gclcip-std-proposals@m.gmane.org Original-Received: from mail-oa0-f69.google.com ([209.85.219.69]) by plane.gmane.org with esmtp (Exim 4.69) (envelope-from ) id 1VQ91D-0006qD-F6 for gclcip-std-proposals@m.gmane.org; Sun, 29 Sep 2013 06:54:07 +0200 Original-Received: by mail-oa0-f69.google.com with SMTP id n10sf13477563oag.4 for ; Sat, 28 Sep 2013 21:54:06 -0700 (PDT) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20130820; h=date:from:to:message-id:in-reply-to:references:subject:mime-version :x-original-sender:reply-to:precedence:mailing-list:list-id :list-post:list-help:list-archive:list-subscribe:list-unsubscribe :content-type; bh=Lyd13cT1NEn8EG1bnLgMMBQj2OgVZNEEuLFoTo58f0I=; b=BVGksnJsNPr+anNTQQ+Z5jb4pE+FbTlvvexxLgKzy04OzPU51fx5e+rlpECkpfpWgW jJt3oYMt3epeNaeSArMX9J5MppNbYHyr1vyzgWOQT6KVgpBCXBUPxLDnC4PBUrTJdJ5F lXD+XLviLZROtkF/29QrslOR4FhfCmK5nyZA0Xc3+wCklUv+zo2wrcOxxVVuKEjiO318 Hf1pqEZIvYFXO8SNHqA4QENthu6/vO1/RZcZok/dsc3guOiIvs1j7InL+ikTXMIxZqsR kxkznpiVsv9p1Sw0Y2P54EdxtYuoagm7AnKDMVrArMm4FBLqMXqg4ajklaK2DwiEuITA jJbQ== X-Received: by 10.43.154.8 with SMTP id lc8mr9326939icc.16.1380430446247; Sat, 28 Sep 2013 21:54:06 -0700 (PDT) X-BeenThere: std-proposals@isocpp.org Original-Received: by 10.50.122.74 with SMTP id lq10ls1216970igb.36.canary; Sat, 28 Sep 2013 21:54:05 -0700 (PDT) X-Received: by 10.50.16.111 with SMTP id f15mr312547igd.2.1380430445557; Sat, 28 Sep 2013 21:54:05 -0700 (PDT) In-Reply-To: <70662a4d-21e1-4705-bb69-e99dfde5ee90@isocpp.org> X-Original-Sender: vlad.moscow@mail.ru Precedence: list Mailing-list: list std-proposals@isocpp.org; contact std-proposals+owners@isocpp.org List-ID: X-Google-Group-Id: 399137483710 List-Post: , List-Help: , List-Archive: List-Subscribe: , List-Unsubscribe: , Xref: news.gmane.org gmane.comp.lang.c++.isocpp.proposals:6752 Archived-At: ------=_Part_1278_6319418.1380430443838 Content-Type: text/plain; charset=KOI8-R Content-Transfer-Encoding: quoted-printable I tested my wonderfull iterator iterator_pair and it works fine. For exampl= e =20 [code] std::map m; std::string s =3D "Hello new iterator \"std::iterator_pair\"!"; std::istringstream is( s ); int i =3D 0; std::transform( std::istream_iterator( is ), std::istream_iterator(), std::inserter( m, m.begin() ),=20 [&i]( const std::string &s ) { return ( std::make_pair( i++, s ) ); } );= =20 =20 std::vector v1( m.size() ); std::vector v2( m.size() ); std::copy( m.begin(), m.end(),=20 usr::make_iterator_pair( v1.begin(), v2.begin() ) ); =20 for ( int x : v1 ) std::cout << x << ' '; std::cout << std::endl; =20 for ( const std::string &s : v2 ) std::cout << s << ' '; std::cout << std::endl; [/code] =20 =20 However it seems that I found a very serious defect of the C++ Standard. =20 If to change the code above the following way =20 [code] std::map m; std::string s =3D "Hello new iterator \"std::iterator_pair\"!"; std::istringstream is( s ); int i =3D 0; std::transform( std::istream_iterator( is ), std::istream_iterator(), std::inserter( m, m.begin() ),=20 [&i]( const std::string &s ) { return ( std::make_pair( i++, s ) ); } );= =20 =20 std::vector v1; std::vector v2; v1.reserve( m.size() ); v2.reserve( m.size() ); =20 std::copy( m.begin(), m.end(),=20 usr::make_iterator_pair( std::back_inserter( v1 ), std::back_inserter( v2= =20 ) ) ); =20 for ( int x : v1 ) std::cout << x << ' '; std::cout << std::endl; =20 for ( const std::string &s : v2 ) std::cout << s << ' '; std::cout << std::endl; [/code] =20 It will not be compiled. The problem is that std::back_inserter is an=20 output iterator and its value_type is defined as void. As the result I get= =20 std::pair. =20 Let's consider the following two iterators =20 std::ostream_iterator it1( std::cout, "\n" ); std::ostream_iterator it2( std::cout, "\n" ); They are different though the both have the same template definitions. What= =20 is the difference? =20 You may write =20 it1 =3D "abc"; it2 =3D 123; but you may not write =20 it1 =3D 123; it2 =3D "abc"; =20 What does this mean? =20 It means that these two iterators have different value types!=20 And as we see value type is an integral and important part of these=20 iterators. So these iterators have defined value types. However in the C++ Standard they are defined such a way that their=20 value_type is defined as void. It is a serious defect of the standard. The value_type for output iterators= =20 shall not be defined as void because each output iterator including above= =20 mentioned and also std::back_insert_iterator, std::front_insert_iterator,= =20 and std::insert_iterator have concrete value types as I showed in the=20 example above with std::ostream_iterator. =20 So each output iterator either shall have its defined value_type or=20 retranslate the value_type of an underlined iterator. =20 Let's consider another simple example. =20 template void SomeFunction( OutputIterator iterator ) { // some code } =20 And let's assume that we are going to define a variable inside the function= =20 body that will have the type that may be processed by iterator. As the=20 iterator has value_type void there is no possibility to determine the type= =20 of the variable. =20 template void SomeFunction( OutputIterator iterator ) { WhatType? our_variable; } =20 I am sure that all output iterators must have a concrete value_type that=20 will differ from void. =D7=CF=D3=CB=D2=C5=D3=C5=CE=D8=C5, 29 =D3=C5=CE=D4=D1=C2=D2=D1 2013 =C7., 0= :59:11 UTC+4 =D0=CF=CC=D8=DA=CF=D7=C1=D4=C5=CC=D8 Vlad from=20 Moscow =CE=C1=D0=C9=D3=C1=CC: > A revised version of the iterator definition > =20 > [code] > namespace usr > { > template > class iterator_pair : public iterator void, void>=20 > { > public: > typedef pair iterator_type; > iterator_pair( Iterator1, Iterator2 ); > explicit iterator_pair( const pair & ); > explicit iterator_pair( pair && ); > iterator_type base() const; > =20 > iterator_pair & > operator =3D( const pair::value_type= , > typename iterator_traits::value_type> = &=20 > ); > iterator_pair & > operator =3D( pair::value_type, > typename iterator_traits::value_type> && = ); > iterator_pair & operator *(); > iterator_pair & operator ++(); > iterator_pair operator ++( int ); > protected: > iterator_type it; > }; > template > iterator_pair make_iterator_pair( Iterator1,=20 > Iterator2 ); > template > iterator_pair make_iterator_pair( const=20 > pair & ); > template > iterator_pair make_iterator_pair( pair Iterator2> && ); > } > [/code] > =20 > > =D3=D5=C2=C2=CF=D4=C1, 28 =D3=C5=CE=D4=D1=C2=D2=D1 2013 =C7., 22:54:24 UT= C+4 =D0=CF=CC=D8=DA=CF=D7=C1=D4=C5=CC=D8 Vlad from Moscow=20 > =CE=C1=D0=C9=D3=C1=CC: > >> Here is an outline of the iterator definition >> =20 >> [code] >> namespace std >> { >> template >> class iterator_pair : public iterator> void, void>=20 >> { >> public: >> typedef pair iterator_type; >> iterator_pair( Iterator1, Iterator2 ); >> iterator_pair( pair ); >> iterator_type base() const; >> =20 >> iterator_pair & >> operator =3D( const pair::value_typ= e, >> typename iterator_traits::value_type>= =20 >> & ); >> iterator_pair & >> operator =3D( pair::value_type, >> typename iterator_traits::value_type> &&= =20 >> ); >> iterator_pair & operator *(); >> iterator_pair & operator ++(); >> iterator_pair operator ++( int ); >> protected: >> iterator_type it; >> }; >> template >> iterator_pair make_iterator_pair( Iterator1,=20 >> Iterator2 ); >> template >> iterator_pair make_iterator_pair( pair> Iterator2> ); >> } >> [/code] >> =20 >> >> =D0=D1=D4=CE=C9=C3=C1, 27 =D3=C5=CE=D4=D1=C2=D2=D1 2013 =C7., 17:49:27 U= TC+4 =D0=CF=CC=D8=DA=CF=D7=C1=D4=C5=CC=D8 Vlad from=20 >> Moscow =CE=C1=D0=C9=D3=C1=CC: >> >>> Did anybody make a proposal about something as pair_iterator. >>> =20 >>> As an idea: the pair_iterator incorporates two iterators and its=20 >>> value_type is std::pair>> Iterator2::value_type> =20 >>> =20 >>> For example >>> =20 >>> [code] >>> =20 >>> const size_t N =3D 10; >>> int a[N], b[N], c[N], d[N]; >>> =20 >>> std::generate( std::begin( a ), std::end( a ), [] { return std::rand() = %=20 >>> N; } ); >>> std::generate( std::begin( b ), std::end( b ), [] { return std::rand() = %=20 >>> N; } ); >>> =20 >>> std::transform( std::begin( a ), std::end( a ), std::begin( b ),=20 >>> std::make_pair_iterator( c, d ), >>> std::minmax ); >>> [/code] >>> =20 >>> Array c is filled with minimum values of elements of arrays a and b=20 >>> while array d is filled with maximumj values of elements of arrays a an= d b. >>> >> =20 >> >>> Any feedback is appreciated.=20 >>> >> --=20 ---=20 You received this message because you are subscribed to the Google Groups "= ISO C++ Standard - Future Proposals" group. To unsubscribe from this group and stop receiving emails from it, send an e= mail to std-proposals+unsubscribe@isocpp.org. To post to this group, send email to std-proposals@isocpp.org. Visit this group at http://groups.google.com/a/isocpp.org/group/std-proposa= ls/. ------=_Part_1278_6319418.1380430443838 Content-Type: text/html; charset=KOI8-R Content-Transfer-Encoding: quoted-printable
I tested my wonderfull iterator iterator_pair and it = works fine. For example
 
[code]
std::ma= p<int, std::string> m;
std::string s =3D "Hello new iterato= r \"std::iterator_pair\"!";
std::istringstream is( s );
int i = =3D 0;
std::transform( std::istream_iterator<std::string&g= t;( is ),
  std::istream_iterator<std::string>(),
&nb= sp; std::inserter( m, m.begin() ),
  [&i]( const std= ::string &s ) { return ( std::make_pair( i++, s ) ); } );
&n= bsp;
std::vector<int> v1( m.size() );
std::vector<std= ::string> v2( m.size() );
std::copy( m.begin(), m.end(), <= br> usr::make_iterator_pair( v1.begin(), v2.begin() ) );
&nb= sp;
for ( int x : v1 ) std::cout << x << ' ';
std:= :cout << std::endl;
 
for ( const std::strin= g &s : v2 ) std::cout << s << ' ';
std::cout << st= d::endl;
[/code]
 
 
= However it seems that I found a very serious defect of the C++ Standard.
 
If to change the code above the following way
 
[code]
std::map<int, std::string> m;=
std::string s =3D "Hello new iterator \"std::iterator_pair\"!";<= br>std::istringstream is( s );
int i =3D 0;

std::tr= ansform( std::istream_iterator<std::string>( is ),
  std= ::istream_iterator<std::string>(),
  std::inserter( m, m= ..begin() ),
  [&i]( const std::string &s ) { return (= std::make_pair( i++, s ) ); } );
 
std::vector&l= t;int> v1;
std::vector<std::string> v2;
v1.reserve( m= ..size() );
v2.reserve( m.size() );
 
std::copy(= m.begin(), m.end(),
 usr::make_iterator_pair( std::back_inserter(= v1 ), std::back_inserter( v2 ) ) );
 
for ( int x= : v1 ) std::cout << x << ' ';
std::cout << std::endl;=
 
for ( const std::string &s : v2 ) std::cout= << s << ' ';
std::cout << std::endl;
[/code]
=
 
It will not be compiled. The problem is that std::bac= k_inserter is an output iterator and its value_type is defined as void. As = the result I get std::pair<void, void>.
 
Le= t's consider the following two iterators
 
std::os= tream_iterator<std::string> it1( std::cout, "\n" );
std::ostream_i= terator<int> it2( std::cout, "\n" );
They are different= though the both have the same template definitions. What is the difference= ?
 
You may write
 
= it1 =3D "abc";
it2 =3D 123;
but you may not write
 
it1 =3D 123;
it2 =3D "abc";
 
What does this mean?
 
It means that these = two iterators have different value types!
And as we see value ty= pe is an integral and important part of these iterators. So these iterators= have defined value types.
However in the C++ Standard they are d= efined such a way that their value_type is defined as void.
It is= a serious defect of the standard. The value_type for output iterators shal= l not be defined as void because each output iterator including above menti= oned and also std::back_insert_iterator, std::front_insert_iterator, and st= d::insert_iterator have concrete value types as I showed in the example abo= ve with std::ostream_iterator.
 
So each output it= erator either shall have its defined value_type or retranslate the value_ty= pe of an underlined iterator.
 
Let's consider ano= ther simple example.
 
template <OutputIterator= >
void SomeFunction( OutputIterator iterator )
{
// some code
}
 
And let's assume= that we are going to define a variable inside the function body that will = have the type that may be processed by iterator. As the iterator has value_= type void there is no possibility to determine the type of the variable.
 
template <OutputIterator>
voi= d SomeFunction( OutputIterator iterator )
{
WhatType? o= ur_variable;
}
 
I am sure that all outp= ut iterators must have a concrete value_type that will differ from void.

=D7=CF=D3=CB=D2=C5=D3=C5=CE=D8=C5, 29 =D3=C5=CE= =D4=D1=C2=D2=D1 2013 =C7., 0:59:11 UTC+4 =D0=CF=CC=D8=DA=CF=D7=C1=D4= =C5=CC=D8 Vlad from Moscow =CE=C1=D0=C9=D3=C1=CC:
A revised version of the iterator definition=
 
[code]
namespace usr
{
t= emplate <class Iterator1, class Iterator2>
class iterator_pair : p= ublic iterator<output_iterator_tag, void, void, void, void>
{
= public:
 typedef pair<Iterator1, Iterator2> iterator_typ= e;
 iterator_pair( Iterator1, Iterator2 );
 explicit= iterator_pair( const pair<Iterator1, Iterator2> & );
 ex= plicit iterator_pair( pair<Iterator1, Iterator2> && );
<= div> iterator_type base() const;
 
 iterator_pair<I= terator1, Iterator2> &
 operator =3D( const pair<typename= iterator_traits<Iterator1>::value_type,
   &n= bsp;            = ;        typename iterator_traits<Ite= rator2>::value_type> & );
 iterator_pair<I= terator1, Iterator2> &
 operator =3D( pair<typename itera= tor_traits<Iterator1>::value_type,
    &n= bsp;            = ;    typename iterator_traits<Iterator2>::value_t= ype> && );
 iterator_pair<Iterator1, Iterator2= > & operator *();
 iterator_pair<Iterator1, Iterator2>= & operator ++();
 iterator_pair<Iterator1, Iterator2>&nb= sp;  operator ++( int );
protected:
 iterator_type i= t;
};
template <class Iterator1, class Iterator2>
ite= rator_pair<Iterator1, Iterator2> make_iterator_pair( Iterator1, Itera= tor2 );
template <class Iterator1, class Iterator2>
iter= ator_pair<Iterator1, Iterator2> make_iterator_pair( const pair<Ite= rator1, Iterator2> & );
template <class Iterator1, clas= s Iterator2>
iterator_pair<Iterator1, Iterator2> make_iterator_= pair( pair<Iterator1, Iterator2> && );
}
<= div>[/code]
 

=D3=D5=C2=C2=CF=D4=C1, 28 =D3=C5= =CE=D4=D1=C2=D2=D1 2013 =C7., 22:54:24 UTC+4 =D0=CF=CC=D8=DA=CF=D7=C1= =D4=C5=CC=D8 Vlad from Moscow =CE=C1=D0=C9=D3=C1=CC:
Here is an outline of the iterator d= efinition
 
[code]
namespace std
{
template <class Iterator1, class Iterator2>
class i= terator_pair : public iterator<output_iterator_tag, void, void, void, vo= id>
{
public:
 typedef pair<Iterator1, Iterator2>&n= bsp;iterator_type;
 iterator_pair( Iterator1, Iterator2 ); iterator_pair( pair<Iterator1, Iterator2> );
 = iterator_type base() const;
 
 iterator_pair<Iterator1, = Iterator2> &
 operator =3D( const pair<typename iterator_= traits<Iterator1>::value_type,
     =             &nb= sp;      typename iterator_traits<Iterator2>= ::value_type> & );
 iterator_pair<Iterator1, = Iterator2> &
 operator =3D( pair<typename iterator_traits= <Iterator1>::value_type,
      =             &nb= sp;  typename iterator_traits<Iterator2>::value_type> &a= mp;& );
 iterator_pair<Iterator1, Iterator2> &= operator *();
 iterator_pair<Iterator1, Iterator2> & ope= rator ++();
 iterator_pair<Iterator1, Iterator2>   = operator ++( int );
protected:
 iterator_type it;
};
template <class Iterator1, class Iterator2>
iterator_pair= <Iterator1, Iterator2> make_iterator_pair( Iterator1, Iterator2 );
template <class Iterator1, class Iterator2>
iterator_pair&= lt;Iterator1, Iterator2> make_iterator_pair( pair<Iterator1, Iterator= 2> );
}
[/code]
 

= =D0=D1=D4=CE=C9=C3=C1, 27 =D3=C5=CE=D4=D1=C2=D2=D1 2013 =C7., 17:49:27= UTC+4 =D0=CF=CC=D8=DA=CF=D7=C1=D4=C5=CC=D8 Vlad from Moscow =CE=C1=D0=C9= =D3=C1=CC:
Did anyb= ody make a proposal about something as pair_iterator.
 =
As an idea: the pair_iterator incorporates two iterators and its= value_type is std::pair<typename Iterator1::value_type, typename Iterat= or2::value_type> 
 
For example
 
[code]
 
const size_t N =3D 10;<= /div>
int a[N], b[N], c[N], d[N];
 
std::gener= ate( std::begin( a ), std::end( a ), [] { return std::rand() % N; } );
std::generate( std::begin( b ), std::end( b ), [] { re= turn std::rand() % N; } );
 
std::transform( std::= begin( a ), std::end( a ), std::begin( b ),
   &n= bsp;            = ;        std::make_pair_iterator( c, d )= ,
          &nb= sp;            = std::minmax );
[/code]
 
Array c is fil= led with minimum values of elements of arrays a and b while array d is fill= ed with maximumj values of elements of arrays a and b.
 
Any feedback is appreciated. 

--
 
---
You received this message because you are subscribed to the Google Groups &= quot;ISO C++ Standard - Future Proposals" group.
To unsubscribe from this group and stop receiving emails from it, send an e= mail to std-proposals+unsubscribe@isocpp.org.
To post to this group, send email to std-proposals@isocpp.org.
Visit this group at http://groups.google.com/a/isocpp.org/group/std-proposals/<= /a>.
------=_Part_1278_6319418.1380430443838-- .