Funktionsschablonen in C++

Überladung eines Verbs

Eine Funktion soll das Maximum zweier ganzzahliger Werte berechnen.

maximum (Funktionsdefinition)

int maximum( int const a, int const b ){ return a > b ? a : b; }

Für das Verb »maximum« kann bei Bedarf auch noch eine Überladung zur Berechnung des Maximums von double -Werten definiert werden.

maximum (Funktionsdefinition)

double maximum( double const a, double const b ){ return a > b ? a : b; }

Vergleicht man die beiden Funktionsdefinitionen, so fällt auf, daß sie sich nur in ihrem Datentyp unterscheiden. In Falle von Wiederholungen in einem Programm, ist es immer wünschenswert, daß die gemeinsamen, sich wiederholenden, Teile nur einmal vorkommen.

Definieren einer Schablone

Die beiden Funktionsdefinitionen können tatsächlich durch eine einzige Funktionsdefinition ersetzt werden, für die der Datentyp offengelassen wird. Dazu muß dieser mit Hilfe einer Schablonenschreibweise abstrahiert werden.

maximum (Funktionsschablone)

template< typename T >
T maximum( T const a, T const b ){ return a > b ? a : b; }

Anwendung einer Schablone

Die Funktionsschablone kann dann angewendet werden, indem der zuvor abstrahierte Datentyp bei der Verwendung wieder angegeben wird. So ist der Wert des Ausdrucks "maximum< int>( 10, 10 )" das Maximum der beiden int -Werte und der Wert des Ausdrucks "maximum< double >( 10., 10. )" ist das Maximum der beiden double -Argumente.

Man beachte, daß der Typ des gesamten Aufrufs auch jeweils der Typ der Argumente ist, also von den Typen der Argumente abhängt: Sind die beiden Argumente vom Typ "int", so ist auch der Wert der Anwendung vom Typ "int", sind die beiden Argumente vom Typ "double", so ist auch der Wert der Anwendung vom Typ "double".

main.cpp

#include <iostream> // ::std::cout
#include <ostream>  // <<
template< typename T >
T maximum( T const a, T const b ){ return a > b ? a : b; }
int main()
{ ::std::cout << maximum< int >( 10, 10 )<< '\n'; 
  ::std::cout << maximum< double >( 10.0, 10.0 )<< '\n'; }

Protokoll

10
10

Das int-Argument wird nach »double« gewandelt.

main.cpp

#include <iostream> // ::std::cout
#include <ostream>  // <<
template< typename T >
T maximum( T const a, T const b ){ return a > b ? a : b; }
int main()
{ ::std::cout << maximum< double >( 10.0, 10 )<< '\n'; }

Protokoll

Anwendung ohne Typangabe

Wenn der abstrahierte Datentyp aus dem Typ der Argumente gefolgert werden kann, dann ist allerdings keine Angabe nötig, so daß auch der Ausdruck "maximum( 10, 10 )" das Maximum der beiden int -Argumente und der Ausdruck "maximum( 10., 10. )" das Maximum der beiden double -Argumente ist.

main.cpp

#include <iostream> // ::std::cout
#include <ostream>  // <<
template<typename T>
T maximum( T const a, T const b ){ return a > b ? a : b; }
int main()
{ ::std::cout << maximum( 10, 10 )<< '\n'; 
  ::std::cout << maximum( 10.0, 10.0 )<< '\n'; }

Protokoll

10
10

Man beachte, daß die Schablonendefinition auch ausdrückt,

daß der Typ der beiden Argumente gleich ist und
daß der Typ des Aufrufs gleich dem Typ der Argumente ist,

indem jedes Mal »T« verwendet wird.

Das int-Argument wird nicht implizit nach »double« gewandelt. Hier gibt es keine impliziten Wandlungen / keine Toleranz!

main.cpp

#include <iostream> // ::std::cout
#include <ostream>  // <<
template< typename T >
T maximum( T const a, T const b ){ return a > b ? a : b; }
int main()
{ ::std::cout << maximum( 10.0, 10 )<< '\n'; }

Protokoll (gekürzt)

error: deduced conflicting types for parameter 'T' ('double' and 'int')

Spezialisierungen

Durch eine Spezialisierung mit »template<>« kann eine spezielle Überladung für einen bestimmten Typ festgelegt werden, die dann bevorzugt verwendet wird, falls möglich.

main.cpp

#include <iostream> // ::std::cout
#include <ostream>  // <<
#include <string>
using namespace ::std::literals;
template< typename T >void print_type( T ){ ::std::cout << "unbekannt"s << "\n"s; }
template<> void print_type( double ){ ::std::cout << "double"s << "\n"s; }
int main()
{ print_type( 10 ); 
  print_type( 10.0 ); }

Protokoll

unbekannt
double

Allerdings hat hier eine gewöhnliche Überladung ohne »template<>« denselben Effekt. Auch hier werden speziellere Definitionen bevorzugt aufgerufen, falls möglich.

main.cpp

#include <iostream> // ::std::cout
#include <ostream>  // <<
#include <string>
using namespace ::std::literals;
template< typename T >void print_type( T ){ ::std::cout << "unbekannt"s << "\n"s; }
void print_type( double ){ ::std::cout << "double"s << "\n"s; }
int main()
{ print_type( 10 ); 
  print_type( 10.0 ); }

Protokoll

unbekannt
double

Kombination mit »`auto`«

Um einen Operator durch eine Funktion nachzubilden, sollten zwei unterschiedliche Typen verwendet werden, da ein Operator auch mit unterschiedlichen Typen aufgerufen werden kann. Außerdem kann keine dieser beiden Typen als Ergebnistyp verwendet werden, vielmehr muß »auto« verwendet werden, um den Typ der Operatoranwendung zu übernehmen.

mul.txt

template< typename T, typename U >auto mul( T x, U y ){ return x * y; }

GCC/clang »`__PRETTY_FUNCTION__`«

Die Erweiterung (kein Standard-C++ !) »__PRETTY_FUNCTION__« (MSVC: »__FUNCSIG__«) ist bei einigen C++ -Implementationen zu finden und erlaubt die Anzeige der Schablonenargumentbesetzungen bei der Anwendung einer Schablone.

main.cpp

#include <iostream> // ::std::cout
#include <ostream>  // <<
#include <string>
using namespace ::std::literals;
template<typename T>
void f( T x )
{ ::std::cout << __PRETTY_FUNCTION__ << '\n'; }
int main()
{ int a = 2;
  f( 2 );
  f( a ); 
  f( 2.3 );
  f( "2.3"s );
  f( __PRETTY_FUNCTION__ ); }

Protokoll

void f(T) [with T = int]
void f(T) [with T = int]
void f(T) [with T = double]
void f(T) [with T = std::__cxx11::basic_string<char>]
void f(T) [with T = const char*]

Man könnte dies auch verwenden, um den Typ eines Ausdrucks zu bestimmen, jedoch gibt es bei der Typableitung für Schablonen einige Sonderregeln, die man dann noch kennen sollte. Daher ist der oben angezeigte Typ »const char*« nicht ganz korrekt. Außerdem wurde die Bedeutung der Schreibweise »std::__cxx11::basic_string<char>« im Kurs bisher noch nicht behandelt, gemeint ist damit aber tatsächlich »::std::string«!

Übungsfragen

? Übungsfrage

Übungsaufgaben

/ Übungsaufgabe

Implementieren Sie ein Verb »abs_d« zur Berechnung des Betrags eines Wertes »x« vom Typ double oder int, so daß der Typ von »abs(x)« der Typ »double«.

/ Übungsaufgabe

Implementieren Sie ein Verb »abs_p« zur Berechnung des Betrags eines Wertes »x« vom Typ double oder int, so daß der Typ von »abs(x)« der Typ von »x« ist.

/ Übungsaufgabe

Implementieren Sie ein Verb »println«, die einen ihr übergebenen Wert ausgibt und die Ausgabe mit einem Zeilenende abschließt. Der Argumentausdruck jener Funktion soll den Typ »int«, »double« oder »string« haben können (darüberhinaus dürfen andere Typen aus akzeptiert werden).

/ Übungsaufgabe

Überarbeiten Sie das Verb »println« so, daß bei Verwendung eines Arguments vom Typ »::std::string«, die ausgegebene Zeichenfolge in Anführungszeichen erscheint.

Funktionsschablonen in C++

Überladung eines Verbs

Definieren einer Schablone

Anwendung einer Schablone

Anwendung ohne Typangabe

Spezialisierungen

Kombination mit »auto«

GCC/clang »__PRETTY_FUNCTION__«

Übungsfragen

? Übungsfrage

Übungsaufgaben

/ Übungsaufgabe

/ Übungsaufgabe

/ Übungsaufgabe

/ Übungsaufgabe

Kombination mit »`auto`«

GCC/clang »`__PRETTY_FUNCTION__`«