Verschieben von Positionen in C++
Hier darf die Position nicht »const« sein.
Verschieben nach vorne
- Drei Objekte und vier Positionen
.-----------.-----------.-----------.
Objekte | a | b | c |
'-----------'-----------'-----------'^ ^ ^
| ++ | ++ | ++ |
| --------> | --------> | --------> |
| | | |Positionen Anfang Deckel
main.cpp#include <initializer_list>
#include <iostream>
#include <iterator>
#include <ostream>
#include <string>using namespace ::std::literals;
int main()
{ ::std::string s = "abc"s;
auto b = cbegin( s );
::std::cout << *b << '\n'; ++b;
::std::cout << *b << '\n'; ++b;
::std::cout << *b << '\n'; ++b; }transcripta
b
c
Verschieben nach hinten
- Drei Objekte und vier Positionen
.-----------.-----------.-----------.
Objekte | a | b | c |
'-----------'-----------'-----------'^ ^ ^
| -- | -- | -- |
| <-------- | <-------- | <-------- |
| | | |Positionen Anfang Deckel
main.cpp#include <initializer_list>
#include <iostream>
#include <iterator>
#include <ostream>
#include <string>using namespace ::std::literals;
int main()
{ ::std::string s = "abc"s;
auto t = cend( s );
--t; ::std::cout << *t << '\n';
--t; ::std::cout << *t << '\n';
--t; ::std::cout << *t << '\n'; }transcriptc
b
a
Zulässige Positionen
Eine Position eines Bereiches darf nur der Anfang jenes Bereichs sein, eine daraus mit »++« erhaltene Position, solange das Ende jenes Bereichs noch nicht erreicht wurde, oder der Deckel jenes Bereichs (oder eine daraus mit »--« erhaltene Position, solange der Anfang jenes Bereichs noch nicht erreicht wurde).
verboten sind Positionen „vor dem Anfang“: verboten: auto b = cbegin( s ); --b;
verboten sind Positionen „hinter dem Deckel“: verboten: auto t = cend( s ); ++t;
Der Deckel darf nicht dereferenziert werden.
verboten: auto t = cend( s ); *t;
Vergleiche mit dem Deckel
Nicht alle Positionen können in jede Richtung verschoben werden. Manche nur nach vorne, manche nur nach hinten. Dies kann vom Typ der Folge abhängen, auf die sie sich beziehen.
main.cpp#include <iostream>
#include <ostream>
#include <string>
#include <iterator>
#include <initializer_list>int main()
{ ::std::string const str{ "abc" };
auto p = cbegin( str );
::std::cout <<( p == cend( str ))<< *p << '\n'; ++p;
::std::cout <<( p == cend( str ))<< *p << '\n'; ++p;
::std::cout <<( p == cend( str ))<< *p << '\n'; ++p;
::std::cout <<( p == cend( str ))<< '\n'; }::std::cout0a
0b
0c
1
Schleifen
Aufwärtsschleifen
Bei Aufwärtsschleifen wird nach dem Schleifeninhalt inkrementiert.
main.cpp#include <initializer_list>
#include <iostream>
#include <iterator>
#include <ostream>
#include <string>using namespace ::std::literals;
int main()
{ ::std::string const s = "abc"s; auto const top = cend( s );
for( auto p = cbegin( s ); p != top; ++p )
::std::cout << *p << '\n'; }Protokolla
b
c
Die Variable »top« verhindert einen eventuellen mehrfachen unnötigen Aufruf der Funktion »::std::cend« bei jedem Schleifendurchlauf.
Diese Regel kann man auch für Schleifen mit Zahlenwerten anwenden.
main.cpp#include <initializer_list>
#include <iostream>
#include <iterator>
#include <ostream>
#include <string>using namespace ::std::literals;
int main()
{ for( auto u = 0u; u != 3u; ++u )
::std::cout << u << '\n'; }transcript0
1
2
Abwärtsschleifen
Bei Abwärtsschleifen wird vor dem Schleifeninhalt inkrementiert. Es ist darauf zu achten, »p« nicht mehr zu dekrementieren, wenn es schon den Wert »cbegin( s )« hat. Daher nicht : »for( auto p = cend( s ); p-- != cbegin( s ); )«!
main.cpp#include <initializer_list>
#include <iostream>
#include <iterator>
#include <ostream>
#include <string>using namespace ::std::literals;
int main()
{ ::std::string const s = "abc"s; auto const first = cbegin( s );
for( auto p = cend( s ); p != first; )
{ --p; ::std::cout << *p << '\n'; }}Protokollc
b
a
Diese Regel kann man auch für Schleifen mit Zahlenwerten anwenden, selber bei den schwierigen vorzeichenlosen Abwärtsschleifen.
main.cpp#include <initializer_list>
#include <iostream>
#include <iterator>
#include <ostream>
#include <string>using namespace ::std::literals;
int main()
{ for( auto u = 3u; u != 0; )
{ --u; ::std::cout << u << '\n'; }}transcript2
1
0
Zeiger als Iteratoren
Bereichsfunktionen akzeptieren auch Zeiger als Iteratoren.
Hier ist wieder »::std::cbegin« statt »cbegin« nötig!
main.cpp#include <iostream>
#include <ostream>
#include <algorithm>int main()
{ /* v */
int a[]{ 0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30 };
/* 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 */::std::cout << ::std::distance( a, ::std::find( ::std::cbegin( a ), ::std::cend( a ), 22 )) << '\n'; }
::std::cout11
End-Einfüger
»back_inserter( s )« ergibt einen Iterator zum Schreiben an das Ende des Strings »s«.
main.cpp#include <iostream>
#include <ostream>
#include <string>int main()
{ ::std::string s;
auto p = back_inserter( s );
::std::cout << '|' << s << "|\n";
*p++ = 'a'; // * und ++ koennen hier auch entfallen
*p++ = 'b'; // Wirkung ist wie s.push_back( 'b' )
*p++ = 'c';
::std::cout << '|' << s << "|\n"; }::std::coutabc
Kopieren
Eine Schreibiterator kann von »copy« genutzt werden, um dort den angegebenen Bereich hinzukopieren.
main.cpp#include <iostream>
#include <ostream>
#include <string>
#include <algorithm>
#include <initializer_list>int main()
{ ::std::string str{ "abc" };
::std::string t;
copy( cbegin( str ), cend( str ), back_inserter( t ));
::std::cout << t << "\n"; }::std::coutabc