Funktionen mit mehreren Parametern in C++

Diese Lektion stellt die Standardfunktion "::std::pow" als Beispiel einer Funktion mit mehreren Parameter vor.

Die Standardfunktion "::std::pow" erlaubt es, das Ergebnis der Potenzierung des ersten Argumentwertes mit dem zweiten Argumentwert (also den ersten Argumentwert „hoch“ den zweiten Argumentwert) zu beschreiben. Die folgende Dokumentation stellt klar, daß beide Parameter vom Typ "double" sind und das Ergebnis ebenfalls vom Typ "double" ist.

»::std::pow« [Dokumentation]

#include <cmath>
double ::std::pow( double a, double b );

»a« hoch »b« (Potenzierung von »a« mit »b« als Exponent)

Die folgende Programme zeigen eine Anwendung der Funktion "::std::pow" zur Berechnung der Potenzen 10² und 2¹°. Man beachte, daß die Reihenfolge, in der die Argumente geschrieben werden, im allgemeinen den Wert des Ausdrucks mitbestimmt.

Um die Bedeutung von »::std::pow( 10., 2. )« zu verstehen, wird der Wert »10.« des ersten Arguments dem ersten Parameter »a« zugeordnet und der Wert »2.« des zweiten Arguments dem zweiten Parameter »b« zugeordnet. Dann kann man diese beiden Werte in die Dokumentation »a hoch b« einsetzen, und erhält »10. hoch 2.«.

pow10_2.cpp

#include <iostream> 
#include <ostream> 
#include <cmath> 
#include <string>   // ""s
using namespace ::std::literals;
int main() 
{ ::std::cout << ::std::pow( 10., 2. )<< "\n"s; }

::std::cout

pow2_10.cpp

#include <iostream> 
#include <ostream> 
#include <cmath> 
#include <string>   // ""s
using namespace ::std::literals;
int main() 
{ ::std::cout << ::std::pow( 2., 10. )<< "\n"s; }

::std::cout

Aussprache

Im allgemeinen spricht man »f(x,y)« als „f von x und y.“, bei speziellen Funktionen werden jedoch auch spezielle Aussprachen verwendet, so ist »pow(x,y)« „x hoch y“.

Ein Aufruf wie »f( 5.2, 6 )« kann im allgemeinen wie „f von 5 Komma 2 und 6“ gesprochen werden.

Funktionsschablonen

Die Schabloneneinleitung »template< class T >« drückt aus, daß für »T« im folgenden (bis zu dem Semikolon »;«) ein beliebiger Typ eingesetzt werden kann, also: »int max( int a, int b )«, »double max( double a, double b )« oder »::std::string max( ::std::string a, ::std::string b )«.

»::std::max« [Dokumentation] (vereinfacht)

#include <algorithm>
template< class T >T max( T a, T b);

Wir betrachten ein Beispiel mit zwei int-Argumenten.

main.cpp

#include <algorithm>
#include <iostream>
#include <ostream>
#include <string>
using namespace ::std::literals;
int main()
{ ::std::cout << ::std::max( 10.0, 10.0 )<< '\n'; }

Protokoll

Wir betrachten ein Beispiel mit zwei double-Argumenten.

main.cpp

#include <algorithm>
#include <iostream>
#include <ostream>
#include <string>
using namespace ::std::literals;
int main()
{ ::std::cout << ::std::max( 10, 10 )<< '\n'; }

Protokoll

Wir betrachten ein Beispiel mit zwei ::std::string-Argumenten.

main.cpp

#include <algorithm>
#include <iostream>
#include <ostream>
#include <string>
using namespace ::std::literals;
int main()
{ ::std::cout << ::std::max( "abc"s, "abc"s )<< '\n'; }

Protokoll

abc

Im Falle solch einer Schablone müssen dann allerdings beide Argumenttypen genau übereinstimmen müssen. Es gibt keinerlei implizite Wandlungen oder Toleranz.

main.cpp

#include <algorithm>
#include <iostream>
#include <ostream>
#include <string>
using namespace ::std::literals;
int main()
{ ::std::cout << ::std::max( 10.0, 10 )<< '\n'; }

Protokoll (übersetzt)

Fehler: Typen stimmen nicht überein

Nach einer ausdrücklichen Festlegung des Typs »T« mit »< int >« verhält sich die Funktion dann aber wie eine normale Funktion mit zwei int-Parametern.

main.cpp

#include <algorithm>
#include <iostream>
#include <ostream>
#include <string>
using namespace ::std::literals;
int main()
{ ::std::cout << ::std::max< int >( 10.0, 10 )<< '\n'; }

Protokoll

Übungsfragen

? Übungsfrage

»::std::hypot« [Dokumentation]

#include <cmath>
double ::std::hypot( double a, double b );

Wurzel aus »a« zum Quadrat plus »b« zum Quadrat.

? Verstehen der Beschreibung

Wie viele Parameter hat die Funktion "hypot"?

Welche Namen haben die Parameter der Funktion "hypot"?

Welche Typen haben die Parameter der Funktion "hypot"?

Welchen Typ hat ein Aufruf der Funktion "hypot"?

Ändert sich der Wert eines Aufrufs der Funktion "hypot", wenn die Argumente vertauscht werden?

Welchen Sinn könnte die Funktion "hypot" haben, wofür also könnte sie verwendet werden?

? Verständnis von Fachbegriffen ⃗

Zu einer Funktion »f« wird erklärt: „Die Funktion »f« ergibt den Wert ihres Arguments.“. Welchen Wert hat dann »f( 3 )«?

Zu einer Funktion »m« wird erklärt: „Die Funktion »m« ergibt immer den Wert 4.“. Welchen Wert hat dann »m( 3 )«?

Zu einer binären Funktion (einer Funktion mit zwei Parametern) »h« wird erklärt: „Der Wert von »h(x,y)« ist der Wert des linken Arguments.“. Welchen Wert hat demnach »h(4,7)«? Welchen Wert hat »h(h(4,2),7)«?

Beim Schreiben eines Programms mit Aufrufen von Funktionen

sollte nichts aus der Dokumentation in das Programm kopiert werden und
der vorgegebenen Ausdruckrahmen weiterhin nicht verändert werden.

/ Ausgabe eines Ergebnisses: Schreiben Sie ein C++ -Programm, welches das Ergebnis eines Aufrufs der Funktion "hypot" ausgibt. Verwenden Sie Argumentausdrücke, bei denen Sie das Ergebnis des Aufrufs der Funktion "hypot" auch im Kopf ausrechnen können, um richtige Ergebnisse erkennen zu können.
/ Ermittlung des Maximums zweier Werte: Ein Aufruf der Funktion »::std::fmax« ermittelt das Maximum der Werte der beiden Argumente. Schreiben Sie ein Programm, in welchem nach »#include <cmath>« mit der Funktion »::std::fmax« das Maximum von 4 und 5 berechnet wird.

? Kugelvolumen

Das folgende C++ -Programm soll das Volumen einer Kugel mit einem Radius von 3 Metern berechnen. Das Volumen ‹ V › einer Kugel mit Radius ‹ r › beträgt ‹ 4/3 π r ³ ›. Wo steckt der Fehler in dem Programm? (Das in der nächsten Zeile verwendete mathematische Symbol ‹ ∧ › bedeutet „und“, das Symbol ‹ ⇒ › hat eine niedrigere Priorität als ‹ ∧ › und bedeutet „daraus folgt“.)

( V = 4/3 π r ³ )∧( r = 3 ) ⇒ V = 4/3 π r ³ ⇒ V = 4/3 π · 3³ = 4 π · 3² = 36 π ≈ 113,09733552923255658465516179806

main.cpp

#include <cmath>    // ::std::atan, ::std::pow
#include <iostream> // ::std::cout
#include <ostream>  // <<
#include <string>   // ""s
using namespace ::std::literals;
int main()
{ ::std::cout << 4/3 *( 4 * ::std::atan( 1 ))* ::std::pow( 3, 3 )<< "\n"s; }

Protokoll

84.823

(In dem Programm wird die Kreiszahl ‹π› als »4 * ::std::atan( 1 )« geschrieben, da es in C++ die Kreiszahl ‹π› nicht als vordefinierte Konstante gibt. An dieser Stelle steckt der Fehler nicht.)

Zitat *

5.2.2. function call p4 When a function is called, each parameter (8.3.5) shall be initialized (8.5, 12.8, 12.1) with its corresponding argument. [ Note: Such initializations are indeterminately sequenced with respect to each other (1.9) — end note ]