Elementfunktionen in C++ 

Neben Unterobjekten können Verbundobjekte auch Funktionen  enthalten.

Mit »::std::make_pair« erzeugte Paare enthalten beispielsweise eine Funktion mit dem Namen »swap«, die ein weiteres Paar als Argument akzeptiert und die Inhalte der beiden Paare miteinander vertauscht.

main.cpp

#include <initializer_list>
#include <ostream>
#include <iostream>
#include <utility> /* ::std::pair, ::std::swap */
int main()
{ auto p { ::std::make_pair( 3, 4 ) };
  auto q { ::std::make_pair( 1, 2 ) };
  p.swap( q );
  ::std::cout << p.first  << '\n';
  ::std::cout << p.second << '\n';
  ::std::cout << q.first  << '\n';
  ::std::cout << q.second << '\n'; }

transcript

1
2
3
4

Aussprachehinweis

swap /swɑp/

Im obigen Programm wollen wir die Funktion mit dem Namen »swap« aus dem Objekt »p« aufrufen. Dazu verwenden wir – wie bei Unterobjekten – einen Eintragspunkt und schreiben den Aufruf der Funktion dahinter.

Das Verhalten eines Aufrufs eines Funktionseintrags kann sowohl durch die Argumentwerte  als auch durch das den Eintrag enthaltende Objekt  beeinflußt werden.

Bezeichnungen

Wir nennen solch eine Funktion, die in einem Objekt eingetragen ist, auch einen Funktionseintrag.

Um die zuvor behandelten Einträge (Unterobjekte) von Funktionseinträgen zu unterscheiden, nennen wird Einträge, die selber keine Funktionen sondern Objekte sind, dann auch Dateneinträge  (oder „Felder“).

Ein solche Funktion wird aber oft auch als Elementfunktion  bezeichnet, dabei stellt man sich vor, daß die Funktion ein „Element“ des Objektes ist, in dem sie eingetragen ist.

Eine solche in einem Objekt enthaltene Funktion wird manchmal als eine Methode  (des Objektes) bezeichnet.

Funktionen, die keine Elementfunktionen sind, werden technisch als „Nicht-Element-Funktion “ oder manchmal auch als „freie Funktionen “ bezeichnet.

Ziele

Die im obigen Programm aufgerufene Funktion »swap« hat allerdings nur einen Parameter und ihre Aufruf enthält entsprechend nur ein Argument. Das vor dem Punkt stehende Objekt »p« gilt also bei diesem Aufruf nicht als Argument, es wird manchmal auch als Zielobjekt  des Aufrufs bezeichnet. Entsprechend bezeichnen wir den Ausdruck »p« in »p.swap( q )« als den Zielausdruck  des Aufrufs »swap( q )«.

Falls die Unterscheidung zwischen dem Zielobjekt und dem Zielausdruck nicht so wichtig ist, so sprechen wir auch einfach vom »Ziel« eines Aufrufs.

Das Schicken/Senden von Aufrufen/Nachrichten

Man sagt zu Beschreibung eines Aufrufs wie »p.swap( q )« auch, daß hier dem Ausdruck »p« beziehungsweise dem Objekt »p« der Aufruf »swap( q )« geschickt  oder gesendet  werde. Den Aufruf bezeichnet man dabei auch als eine Aufrufnachricht  oder als eine Nachricht.

Die freie swap-Funktion

Es gibt auch eine nicht in einem Objekt enthaltene Funktion »::std::swap«, die wir zum Vergleich heranziehen können. Im folgenden Programm benötigt sie natürlich »p« und  »q« als Argumente, damit sie deren Inhalte miteinander vertauschen kann.

main.cpp

#include <initializer_list>
#include <ostream>
#include <iostream>
#include <utility> /* ::std::pair */
#include <algorithm> /* ::std::swap */
int main()
{ auto p { ::std::make_pair( 3, 4 ) };
  auto q { ::std::make_pair( 1, 2 ) };
  ::std::swap( p, q );
  ::std::cout << p.first  << '\n';
  ::std::cout << p.second << '\n';
  ::std::cout << q.first  << '\n';
  ::std::cout << q.second << '\n'; }

transcript

1
2
3
4

Im Falle der obigen beiden Programmbeispiele, ist es egal, ob man »p.swap( q )« oder »::std::swap( p, q )« schreibt, dies ist aber bei anderen Funktionen nicht immer so. Manchmal ist nur die Schreibweise mit Punkt, manchmal nur die ohne Punkt möglich. Im Grundkurs wurden die Aufrufe ohne Punkt schon behandelt; dabei wurde auch gezeigt, wie man ihre Dokumentation findet und versteht. Das Auffinden und Interpretieren der Dokumentationen von Aufrufen mit einem Punkt wird erst etwas später gezeigt werden.

Temporäre und permanente Objekte

Der Ausdruck »"echo"s« steht in dem folgenden Programm für Objekte, die nur während der Auswertung des sie enthaltenden Ausdrucks existieren. Solche Objekte werden temporär  (vorübergehend existent) genannt.

Die Ausdrücke »"echo"s« stehen alle für temporäre Objekte.

Der Ausdruck »s« steht für ein nicht-temporäres Objekt. Dieses existiert nicht nur während der Auswertung des es enthaltenden Ausdrucks. Es wird nämlich nicht schon bei »/* 1 */« zerstört, sondern erst direkt hinter der Stelle »/* 2 */«. (Es könnte direkt vor der Stelle »/* 2 */« erneut verwendet werden.)

main.cpp

#include <initializer_list>
#include <ostream>
#include <iostream>
#include <string>
using namespace ::std::literals;
int main()
{ ::std::cout << "echo"s << '\n';
  ::std::cout << "echo"s << '\n';
  { auto s { "echo"s }; ::std::cout << s << '\n' /* 1 */; /* 2 */}
  ::std::cout << 99 << '\n'; }

transcript

echo
echo
echo
99

Besonders interessant ist die Variablendefinition »auto s { "echo"s };«: Dort wird der Inhalt des temporären Objekts »"echo"s« in das nicht-temporäre Objekt »s« kopiert. Unmittelbar danach wird das temporäre Objekt »"echo"s« aufgelöst, aber sein Inhalt existiert im nicht-temporären Objekt »s« fort.

Die Elementfunktion »c_str()«

Die Elementfunktionen »c_str()« und »data()« ergeben eine Zeichenfolge des Typs »char *« aus einem ::std::string-Objekt, die denselben Text enthält wie das ::std::string-Objekt.

main.cpp

#include <iostream> /* ::std::cout   */
#include <ostream>  /* <<            */
#include <string>   /* ::std::string */
using namespace ::std::literals;
int main() 
{ auto s{ "alpha"s };
  ::std::cout << s.c_str() << "\n";
  ::std::cout << s.::std::string::c_str() << "\n"; }

transcript

alpha
alpha

Der Name einer Elementfunktion kann auch genauer durch Angabe seiner Klasse bestimmt werden, wie oben im Falle von »::std::string::c_str()«, doch ist dies selten nötig.

Die Elementfunktion »c_str()« kann verwendet werden, wenn an einer Stelle eine Zeichenfolge vom Typ »char *« erwartet wird. Beispielsweise, wenn die klassische strlen-Funktion aufgerufen werden soll.

main.cpp

#include <cstring>  /* ::std::strlen */
#include <iostream> /* ::std::cout   */
#include <ostream>  /* <<            */
#include <string>   /* ::std::string */
using namespace ::std::literals;
int main() 
{ auto s{ "alpha"s };
  ::std::cout << ::std::strlen( s.c_str() )<< "\n";
  ::std::cout << ::std::strlen( s.data() )<< "\n"; }

transcript

5
5

In der Regel ist es zu bevorzugen, wenn die Verwendung dieser Funktion in einem Programm auf die Fälle beschränkt wird, in denen sie unbedingt nötig ist, etwa wenn ältere Funktionen aus der Programmiersprache C  verwendet werden müssen.

Das Ergebnis dieser Funktion kann nur solange verwendet werden, wie das ::std::string-Objekt, für das diese Funktion aufgerufen wurde, existiert und nicht verändert wurde. Folgendes wäre also fehlerhaft.

main.cpp

#include <cstring>  /* ::std::strlen */
#include <iostream> /* ::std::cout   */
#include <ostream>  /* <<            */
#include <string>   /* ::std::string */
using namespace ::std::literals;
int main() 
{ char const * p; 
  { auto s{ "alpha"s }; p = s.c_str(); }
  ::std::cout << p << "\n"; }

Klassen

Die Typen von Verbundobjekten (also von Objekten, die Unterobjekte oder Elementfunktionen enthalten können) werden Klassen  genannt.

Ein Objekt, dessen Typ eine Klasse ist, wird auch als ein Exemplar  der Klasse bezeichnet.

Die Dokumentation von Elementfunktion

Die Dokumentation von Objekten, deren Typ eine Klasse ist, findet man in der Dokumentation der Klasse.

Wir zeigen hier eine vereinfachte Form der Proklamation von Elementfunktionen.

Proklamation der Klasse »::std::string«

namespace std
{ class string
  { char const * c_str() const;
    char const * data() const; }}

Entsprechend der Verschachtelungen der geschweiften Klammern bedeutet dies, daß die Klasse »string« im Namensraum »::std« liegt und zwei Funktionen »c_str()« und »data()« enthält.

Die Funktion »c_str()« liefert ein Ergebnis vom Typ »char const *«, was – vereinfacht gesagt – eine konstante C -Zeichenfolge ist, also eine Zeichenfolge wie sie in Funktionen verwendet wird, die C++  aus der Programmiersprache C  übernommen hat. Außerdem hat diese Funktion keine Parameter. Die Bedeutung des Stücks »char const * c_str()« ist wie schon im Grundkurs bei der Behandlung von Funktionsproklamationen erklärt.

Das zweite »const« bedeutet, daß die Funktion das Objekt, zu dem sie gehört, nicht verändert.

Obwohl die Proklamationen der Funktionen in der Proklamation einer Klasse  enthalten sind, gehören sie nicht zur Klasse, sondern zu den Objekten, welche diese Klasse als Typ  haben, also beispielweise zu einem Objekt wie »"abc"s«. Man kann »c_str()« also beispielsweise mit »"abc"s.c_str()« aufrufen.

Für die zweite Funktion »data()« gilt dasselbe wie für »c_str()«.

»sizeof«

Die Größe von Objekten fundamentaler Typen kann mit »sizeof« ermittelt werden. Dies ist zwar auch für Objekte möglich, deren Typ eine Klasse ist, doch sagt der erhaltene Wert bei solchen Objekten nicht immer zuverlässig etwas über den tatsächlichen Speicherverbrauch eines solchen Objektes aus, der manchmal auch größer sein kann. Die Ermittlung des Speicherverbrauchs eines beliebigen Objektes ist nicht immer ganz einfach und soll hier nicht weiter diskutiert werden.

»push_back«

Die Elementfunktion »push_back« erlaubt es ein weiteres Zeichen an eine Zeichenfolge anzuhängen.

main.cpp

#include <iostream>
#include <ostream>
#include <string>
int main() 
{ ::std::string str{ "" };
  str.push_back( 'a' );
  str.push_back( 'b' );
  str.push_back( 'c' );
  ::std::cout << str << "\n"; }

::std::cout

abc

main.cpp

#include <iostream>
#include <ostream>
#include <string> 
#include <initializer_list> 
int main()
{ ::std::string a{ "abc" };
  a.push_back( '0' );
  ::std::cout << a << '\n'; }

::std::cout

abc0

Übungsaufgaben

/   Aufrufe von Funktionseinträgen

In dem folgenden Programm ist »"echo"s« ein Verbundobjekt, das eine Funktion mit dem Namen »size« enthält, die keine Parameter hat. Rufen Sie diese Funktion auf, indem Sie »"echo"s« als Zielausdruck verwenden, und geben Sie das Ergebnis aus, indem Sie das folgende Programm etwas abändern!

main.cpp

#include <iostream> /* ::std::cout         */
#include <ostream>  /* <<                  */
#include <string>   /* ::std::string       */
using namespace ::std::literals;
int main() { ::std::cout << "echo"s << '\n'; }

transcript

echo

Ersetzen Sie dann »echo« durch verschiedene Texte, um die Bedeutung des Ergebnisses des Aufrufs vermuten zu können.

/   Aufrufe von Funktionseinträgen (1)

In dem folgenden Programm ist »"echo"s« ein Verbundobjekt, das eine Funktion mit dem Namen »length« enthält, die keine Parameter hat. Rufen Sie diese Funktion auf und geben Sie das Ergebnis aus, indem Sie das folgende Programm etwas abändern!

main.cpp

#include <iostream> /* ::std::cout         */
#include <ostream>  /* <<                  */
#include <string>   /* ::std::string       */
using namespace ::std::literals;
int main() { ::std::cout << "echo"s << '\n'; }

transcript

echo

Ersetzen Sie dann »echo« durch verschiedene Texte, um die Bedeutung des Ergebnisses des Aufrufs vermuten zu können.

/   Aufrufe von Funktionseinträgen (2)

In dem folgenden Programm ist »"echo"s« ein Verbundobjekt, das eine Funktion mit dem Namen »front« enthält, die keine Parameter hat. Rufen Sie diese Funktion auf und geben Sie das Ergebnis aus, indem Sie das folgende Programm etwas abändern!

main.cpp

#include <iostream> /* ::std::cout         */
#include <ostream>  /* <<                  */
#include <string>   /* ::std::string       */
using namespace ::std::literals;
int main() { ::std::cout << "echo"s << '\n'; }

transcript

echo

Ersetzen Sie dann »echo« durch verschiedene Texte, um die Bedeutung des Ergebnisses des Aufrufs vermuten zu können.

Zusatzaufgabe: Finden Sie durch Ausprobieren heraus, was der Funktionseintrag »back«, der wie »front« aufgerufen wird, macht.

/   Aufrufe von Funktionseinträgen mit Variablen

Ändern Sie das Ergebnis der vorherigen Übungsaufgabe nun folgendermaßen ab: Führen Sie eine Variable für den Wert »"echo"s« ein und verwenden Sie diese Variable als Zielausdruck eines Aufrufs der Funktion »front«.

/   Aufrufe von Funktionseinträgen mit Argumenten

Das Objekt »"echo"s« enthält auch eine Funktion »at« die mit einem int-Argument aufgerufen werden kann. Rufen Sie jene Funktion jenes Objekts mit verschiedenen kleinen ganzen Zahlen auf, um die Bedeutung jener Funktion an Hand der Ergebnisses der Aufrufe erkennen zu können.

Zusatzaufgabe: Tatsächlich kann das Ergebnis eines at-Aufrufs auch auf der linken Seite einer Zuweisung verwendet werden. Versuchen Sie eine solche Zuweisung durchzuführen.

/   Das Senden von Aufrufen an Objekte ⃗

Senden Sie dem Objekt »"echo"s« die Nachricht »find( 'h' )« und versuchen Sie durch Ausprobieren (Variieren des Textes und/oder des Zeichens) herauszufinden, was das Ergebnis der Nachricht bedeuten könnte.

/   Das Senden von Aufrufen an Objekte (2) ⃗

Senden Sie dem Objekt »"echo"s« die Nachrichten »substr( 2 )« und »substr( 1, 2 )« versuchen Sie, durch Ausprobieren herauszufinden, wodurch das Ergebnis bestimmt wird.

/   Das Verändern von Objekten ⃗

Legen Sie ein neues (nicht-temporäres) Objekt mit dem Namen »s« an, das mit dem Ausdruck »"echo"s« initialisiert wird, geben Sie es aus, und senden Sie dem Objekt dann hintereinander die folgenden Nachrichten in der unten gegebenen Reihenfolge und geben Sie dann nach jedem Versand einer Nachricht sowohl den Text der Nachricht als auch den neuen Inhalt des Objektes aus.

• »assign( "delta"s )«
• »clear()«
• »assign( "lima"s )«
• »erase()«
• »append( "alpha"s )«
• »append( "bet"s )«
• »push_back( 'a' )«
• »insert( 5, " "s )«
• »replace( 5, 1, ""s )«
• »erase( 5 )«
• »erase( 1, 2 )«
• »pop_back()«
• »assign( "alpha"s )«

Machen Sie sich an Hand der Ausgabe und unter Zuhilfename englischer Sprachkenntnisse eine Vorstellung von der Bedeutung der Nachrichten. Verändern Sie im Zweifelsfall die Argumentwerte versuchsweise, um Vermutungen über die Bedeutung von Nachrichten zu untersuchen.

/   Das Suchen in Objekten ⃗

Legen Sie ein neues (nicht-temporäres) Objekt mit dem Namen »s« an, das mit dem Ausdruck »"alphaalpha"s« initialisiert wird. Wenn die folgende Nachrichten an das Objekt geschickt werden, so antwortet es jeweils mit einer bestimmten Position. Lassen Sie sich diese Position jeweils ausgeben.

• »find( 'a' )«
• »find( 'a', 1 )«
• »find( 'a', 6 )«
• »rfind( 'a' )«
• »find_first_of( "al"s )«
• »find_last_of( "al"s )«
• »find_first_not_of( "al"s )«
• »find_last_not_of( "al"s )«

Können Sie an Hand der Ausgaben herausfinden, nach welche Regel die einzelnen Elementfunktionen jeweils eine Position ermitteln?

/   Das Verändern von Objekten *

::std::string-Werte (Zeichenfolgen) können wie int-Werte (Zahlen) an Funktionen übergeben oder von Funktionen zurückgegeben werden. Dies haben wir schon im Grundkurs behandelt.

Schreiben Sie eine Funktion »replace«, die drei Parameter vom Typ »::std::string« hat. Sie soll alle Vorkommen des Textes des zweiten Parameters im Text des ersten Parameters durch den Text des dritten Parameters ersetzen und dann den Text des ersten Parameters als Ergebnis zurückgeben.

main.cpp

#include <iostream> /* ::std::cout         */
#include <ostream>  /* <<                  */
#include <string>   /* ::std::string       */
using namespace ::std::literals;

…

int main() 
{ ::std::cout << replace( "Moorochse"s, "o"s,  "e"s  )== "Meerechse"s    << '\n';
  ::std::cout << replace( "abcabcabc"s, "ca"s, "d"s  )== "abdbdbc"s      << '\n';
  ::std::cout << replace( "abcabcabc"s, "c"s,  "de"s )== "abdeabdeabde"s << '\n'; }

transcript

true
true
true

Zur Vereinfachung der Aufgabenstellung können Sie auch nur das erste  Vorkommen des zweiten Parameters ersetzen.