std::pow, std::powf, std::powl

Definiert in der Header-Datei `<cmath>`
	(1)
float pow ( float basis, float exp ); double pow ( double basis, double exp ); long double pow ( long double basis, long double exp );			(bis C++23)
/* floating-point-type / pow ( / floating-point-type / basis, / floating-point-type */ exp )			(seit C++23) (constexpr seit C++26)
float pow ( float basis, int exp ); double pow ( double basis, int exp ); long double pow ( long double basis, int exp );		(2)	(bis C++11)
float powf( float basis, float exp );		(3)	(seit C++11) (constexpr seit C++26)
long double powl( long double basis, long double exp );		(4)	(seit C++11) (constexpr seit C++26)
Zusätzliche Überladungen (seit C++11)
Definiert in der Header-Datei `<cmath>`
template< class Arithmetic1, class Arithmetic2 > /* common-floating-point-type */ pow ( Arithmetic1 basis, Arithmetic2 exp );		(A)	(constexpr seit C++26)

1-4) Berechnet den Wert von basis potenziert mit exp. Die Bibliothek stellt Überladungen von std::pow für alle cv-unqualifizierten Gleitkommatypen als Typ der Parameter basis und exp bereit.(seit C++23)

A) Zusätzliche Überladungen werden für alle anderen Kombinationen von arithmetischen Typen bereitgestellt.

(seit C++11)

[edit] Parameter

base	-	basis als Gleitkomma- oder ganzzahliger Wert
exp	-	Exponent als Gleitkomma- oder ganzzahliger Wert

[edit] Rückgabewert

Wenn keine Fehler auftreten, wird basis hoch exp ( $basis exp$ ) zurückgegeben.

Wenn ein Domänenfehler auftritt, wird ein implementierungsabhängiger Wert zurückgegeben (NaN, wo unterstützt).

Wenn ein Polfehler oder ein Bereichsfehler aufgrund eines Überlaufs auftritt, wird ±HUGE_VAL, ±HUGE_VALF oder ±HUGE_VALL zurückgegeben.

Wenn ein Bereichsfehler aufgrund eines Unterlaufs auftritt, wird das korrekte Ergebnis (nach Rundung) zurückgegeben.

[edit] Fehlerbehandlung

Fehler werden wie in math_errhandling beschrieben gemeldet.

Wenn basis endlich und negativ ist und exp endlich und nicht-ganzzahlig ist, tritt ein Domänenfehler auf und möglicherweise ein Bereichsfehler.

Wenn basis Null ist und exp Null ist, kann ein Domänenfehler auftreten.

Wenn basis Null ist und exp negativ ist, können ein Domänenfehler oder ein Polfehler auftreten.

Wenn die Implementierung IEEE-Gleitkomma-Arithmetik (IEC 60559) unterstützt,

pow(+0, exp), wobei exp eine negative ungerade Ganzzahl ist, gibt +∞ zurück und löst FE_DIVBYZERO aus.
pow(-0, exp), wobei exp eine negative ungerade Ganzzahl ist, gibt -∞ zurück und löst FE_DIVBYZERO aus.
pow(±0, exp), wobei exp negativ, endlich und eine gerade Ganzzahl oder eine nicht-ganzzahlige Zahl ist, gibt +∞ zurück und löst FE_DIVBYZERO aus.
pow(±0, -∞) gibt +∞ zurück und kann FE_DIVBYZERO auslösen.
pow(+0, exp), wobei exp eine positive ungerade Ganzzahl ist, gibt +0 zurück.
pow(-0, exp), wobei exp eine positive ungerade Ganzzahl ist, gibt -0 zurück.
pow(±0, exp), wobei exp eine positive nicht-ganzzahlige Zahl oder eine positive gerade Ganzzahl ist, gibt +0 zurück.
pow(-1, ±∞) gibt 1 zurück.
pow(+1, exp) gibt 1 für jedes exp zurück, auch wenn exp NaN ist.
pow(basis, ±0) gibt 1 für jede basis zurück, auch wenn basis NaN ist.
pow(basis, exp) gibt NaN zurück und löst FE_INVALID aus, wenn basis endlich und negativ ist und exp endlich und nicht-ganzzahlig ist.
pow(basis, -∞) gibt +∞ für jedes |basis| < 1 zurück.
pow(basis, -∞) gibt +0 für jedes |basis| > 1 zurück.
pow(basis, +∞) gibt +0 für jedes |basis| < 1 zurück.
pow(basis, +∞) gibt +∞ für jedes |basis| > 1 zurück.
pow(-∞, exp) gibt -0 zurück, wenn exp eine negative ungerade Ganzzahl ist.
pow(-∞, exp) gibt +0 zurück, wenn exp eine negative nicht-ganzzahlige Zahl oder eine negative gerade Ganzzahl ist.
pow(-∞, exp) gibt -∞ zurück, wenn exp eine positive ungerade Ganzzahl ist.
pow(-∞, exp) gibt +∞ zurück, wenn exp eine positive nicht-ganzzahlige Zahl oder eine positive gerade Ganzzahl ist.
pow(+∞, exp) gibt +0 für jede negative exp zurück.
pow(+∞, exp) gibt +∞ für jede positive exp zurück.
Sofern nicht oben anders angegeben, wird NaN zurückgegeben, wenn ein Argument NaN ist.

[edit] Anmerkungen

C++98 fügte Überladungen hinzu, bei denen exp den Typ int hat, zusätzlich zu den C pow(), und der Rückgabetyp von std::pow(float, int) war float. Die in C++11 eingeführten zusätzlichen Überladungen geben jedoch an, dass std::pow(float, int) double zurückgeben sollte. LWG issue 550 wurde erhoben, um diesen Konflikt zu beheben, und die Lösung besteht darin, die zusätzlichen Überladungen mit int exp zu entfernen.

Obwohl std::pow nicht verwendet werden kann, um die Wurzel einer negativen Zahl zu ziehen, wird std::cbrt für den häufigen Fall einer Potenz von 1/3 bereitgestellt.

Die zusätzlichen Überladungen müssen nicht exakt wie (A) angegeben werden. Sie müssen nur ausreichen, um sicherzustellen, dass für ihr erstes Argument num1 und ihr zweites Argument num2

Wenn num1 oder num2 den Typ long double hat, hat std::pow(num1, num2) den gleichen Effekt wie std::pow(static_cast<long double>(num1),
static_cast<long double>(num2)).
Andernfalls, wenn num1 und/oder num2 den Typ double oder einen Ganzzahltyp hat, hat std::pow(num1, num2) den gleichen Effekt wie std::pow(static_cast<double>(num1),
static_cast<double>(num2)).
Andernfalls, wenn num1 oder num2 den Typ float hat, hat std::pow(num1, num2) den gleichen Effekt wie std::pow(static_cast<float>(num1),
static_cast<float>(num2)).

(bis C++23)

Wenn num1 und num2 arithmetische Typen haben, hat std::pow(num1, num2) den gleichen Effekt wie std::pow(static_cast</*common-floating-point-type*/>(num1),
static_cast</*common-floating-point-type*/>(num2)), wobei /*common-floating-point-type*/ der Gleitkommatyp mit dem höchsten Gleitkommakomvertierungsrang und dem höchsten Gleitkommakomvertierungs-Subrang zwischen den Typen von num1 und num2 ist. Argumente vom Ganzzahltyp werden als Gleitkommakomvertierungsrang wie double behandelt.

Wenn kein solcher Gleitkommazahltyp mit dem höchsten Rang und Subrang existiert, dann führt die Überladungsauflösung nicht zu einem nutzbaren Kandidaten aus den bereitgestellten Überladungen.

(seit C++23)

[edit] Beispiel

Führen Sie diesen Code aus

#include <cerrno>
#include <cfenv>
#include <cmath>
#include <cstring>
#include <iostream>
// #pragma STDC FENV_ACCESS ON
 
int main()
{
    // typical usage
    std::cout << "pow(2, 10) = " << std::pow(2, 10) << '\n'
              << "pow(2, 0.5) = " << std::pow(2, 0.5) << '\n'
              << "pow(-2, -3) = " << std::pow(-2, -3) << '\n';
 
    // special values
    std::cout << "pow(-1, NAN) = " << std::pow(-1, NAN) << '\n'
              << "pow(+1, NAN) = " << std::pow(+1, NAN) << '\n'
              << "pow(INFINITY, 2) = " << std::pow(INFINITY, 2) << '\n'
              << "pow(INFINITY, -1) = " << std::pow(INFINITY, -1) << '\n';
 
    // error handling
    errno = 0;
    std::feclearexcept(FE_ALL_EXCEPT);
 
    std::cout << "pow(-1, 1/3) = " << std::pow(-1, 1.0 / 3) << '\n';
    if (errno == EDOM)
        std::cout << "    errno == EDOM " << std::strerror(errno) << '\n';
    if (std::fetestexcept(FE_INVALID))
        std::cout << "    FE_INVALID raised\n";
 
    std::feclearexcept(FE_ALL_EXCEPT);
 
    std::cout << "pow(-0, -3) = " << std::pow(-0.0, -3) << '\n';
    if (std::fetestexcept(FE_DIVBYZERO))
        std::cout << "    FE_DIVBYZERO raised\n";
}

Mögliche Ausgabe

pow(2, 10) = 1024
pow(2, 0.5) = 1.41421
pow(-2, -3) = -0.125
pow(-1, NAN) = nan
pow(+1, NAN) = 1
pow(INFINITY, 2) = inf
pow(INFINITY, -1) = 0
pow(-1, 1/3) = -nan
    errno == EDOM Numerical argument out of domain
    FE_INVALID raised
pow(-0, -3) = -inf
    FE_DIVBYZERO raised

[edit] Siehe auch

sqrtsqrtfsqrtl (C++11)(C++11)	berechnet die Quadratwurzel ($\small{\sqrt{x}}$ $\sqrt x$ ) (Funktion) [bearbeiten]
cbrtcbrtfcbrtl (C++11)(C++11)(C++11)	berechnet die Kubikwurzel ($\small{\sqrt[3]{x}}$ $3 \sqrt x$ ) (Funktion) [bearbeiten]
hypothypotfhypotl (C++11)(C++11)(C++11)	berechnet die Hypotenuse $\scriptsize{\sqrt{x^2+y^2}}$ $\sqrt x 2 +y 2$ und $\scriptsize{\sqrt{x^2+y^2+z^2}}$ $\sqrt x 2 +y 2 +z 2$ (seit C++17) (Funktion) [bearbeiten]
pow(std::complex)	komplexe Potenz, ein oder beide Argumente können komplexe Zahlen sein (function template) [edit]
pow(std::valarray)	wendet die Funktion std::pow auf zwei Valarrays oder ein Valarray und einen Wert an (function template) [edit]
C-Dokumentation für pow

Compiler-Unterstützung
Freestanding und gehostet
Sprache
Standardbibliothek
Header der Standardbibliothek
Benannte Anforderungen
Feature-Test-Makros (C++20)
Bibliothek für Sprachunterstützung
Konzepte-Bibliothek (C++20)
Diagnostik-Bibliothek
Speicherverwaltungsbibliothek
Metaprogrammierungsbibliothek (C++11)
Allgemeine Dienstprogramme-Bibliothek
Container-Bibliothek
Iterator-Bibliothek
Ranges-Bibliothek (C++20)
Algorithmen-Bibliothek
Bibliothek für Zeichenketten
Textverarbeitungsbibliothek
Numerik-Bibliothek
Datums- und Zeitbibliothek
Ein-/Ausgabe-Bibliothek
Dateisystembibliothek (C++17)
Unterstützung für nebenläufige Programmierung (C++11)
Ausführungssteuerungsbibliothek (C++26)
Technische Spezifikationen
Symbolverzeichnis
Externe Bibliotheken

cppreference.com

Namensräume

Varianten

Ansichten

Aktionen