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

From cppreference.net

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

1-4) Berechnet den Wert von base potenziert mit exp . Die Bibliothek stellt Überladungen von


          std::pow

für alle cv-unqualifizierten Gleitkommatypen als Typ der Parameter base und exp bereit. (since C++23)

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

(since C++11)

Inhaltsverzeichnis

Parameter

base	-	Basis als Gleitkomma- oder Ganzzahlwert
exp	-	Exponent als Gleitkomma- oder Ganzzahlwert

Rückgabewert

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

Wenn ein Domänenfehler auftritt, wird ein implementierungsdefinierter Wert zurückgegeben (NaN, sofern unterstützt).

Wenn ein Polfehler oder ein Bereichsfehler aufgrund von Überlauf auftritt, ±HUGE_VAL , ±HUGE_VALF , oder ±HUGE_VALL zurückgegeben.

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

Fehlerbehandlung

Fehler werden gemeldet, wie in math_errhandling festgelegt.

Wenn base endlich und negativ ist und exp endlich und nicht ganzzahlig ist, tritt ein Domänenfehler auf und ein Wertebereichsfehler kann auftreten.

Wenn base null ist und exp null ist, kann ein Domänenfehler auftreten.

Wenn base null ist und exp negativ ist, kann ein Domänenfehler oder ein Polfehler auftreten.

Wenn die Implementierung IEEE-Gleitkommaarithmetik (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-Ganzzahl 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-Ganzzahl 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, selbst wenn exp NaN ist.
pow ( base, ± 0 ) gibt 1 für jede base zurück, selbst wenn base NaN ist.
pow ( base, exp ) gibt NaN zurück und löst FE_INVALID aus, wenn base endlich und negativ ist und exp endlich und keine Ganzzahl ist.
pow ( base, - ∞ ) gibt +∞ für jedes |base| < 1 zurück.
pow ( base, - ∞ ) gibt +0 für jedes |base| > 1 zurück.
pow ( base, + ∞ ) gibt +0 für jedes |base| < 1 zurück.
pow ( base, + ∞ ) gibt +∞ für jedes |base| > 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-Ganzzahl oder 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-Ganzzahl oder positive gerade Ganzzahl ist.
pow ( + ∞, exp ) gibt +0 für jedes negative exp zurück.
pow ( + ∞, exp ) gibt +∞ für jedes positive exp zurück.
sofern nicht oben angegeben, wird NaN zurückgegeben, wenn ein Argument NaN ist.

Hinweise

C++98 fügte Überladungen hinzu, bei denen exp den Typ int hat, zusätzlich zu C pow() , und der Rückgabetyp von std :: pow ( float , int ) war float . Allerdings legen die zusätzlichen Überladungen, die in C++11 eingeführt wurden, fest, dass std :: pow ( float , int ) double zurückgeben soll. LWG Issue 550 wurde eingereicht, um diesen Konflikt zu behandeln, und die Lösung besteht darin, die zusätzlichen int exp Überladungen zu entfernen.

Obwohl std::pow nicht verwendet werden kann, um eine Wurzel einer negativen Zahl zu erhalten, std::cbrt wird für den häufigen Fall bereitgestellt, in dem exp 1/3 beträgt.

Die zusätzlichen Überladungen müssen nicht exakt wie (A) bereitgestellt werden. Sie müssen lediglich sicherstellen, dass für ihr erstes Argument num1 und zweites Argument num2 :

Falls num1 oder num2 den Typ long double hat, dann hat std :: pow ( num1, num2 ) denselben Effekt wie std :: pow ( static_cast < long double > ( num1 ) ,
static_cast < long double > ( num2 ) ) .
Andernfalls, falls num1 und/oder num2 den Typ double oder einen Ganzzahltyp hat, dann hat std :: pow ( num1, num2 ) denselben Effekt wie std :: pow ( static_cast < double > ( num1 ) ,
static_cast < double > ( num2 ) ) .
Andernfalls, falls num1 oder num2 den Typ float hat, dann hat std :: pow ( num1, num2 ) denselben Effekt wie std :: pow ( static_cast < float > ( num1 ) ,
static_cast < float > ( num2 ) ) .

(bis C++23)

Falls num1 und num2 arithmetische Typen haben, dann hat std :: pow ( num1, num2 ) denselben 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 Gleitkomma-Konvertierungsrang und der höchsten Gleitkomma-Konvertierungsunterrang zwischen den Typen von num1 und num2 ist, wobei Argumente vom Ganzzahltyp als denselben Gleitkomma-Konvertierungsrang wie double betrachtet werden.

Falls kein solcher Gleitkommatyp mit dem höchsten Rang und Unterrang existiert, dann führt die Überladungsauflösung nicht zu einem verwendbaren Kandidaten aus den bereitgestellten Überladungen.

(seit C++23)

Beispiel

Diesen Code ausführen

#include <cerrno>
#include <cfenv>
#include <cmath>
#include <cstring>
#include <iostream>
// #pragma STDC FENV_ACCESS ON
int main()
{
    // typische Verwendung
    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';
    // spezielle Werte
    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';
    // Fehlerbehandlung
    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 ausgelöst\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 ausgelöst\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 ausgelöst
pow(-0, -3) = -inf
    FE_DIVBYZERO ausgelöst

Siehe auch

sqrt sqrtf sqrtl (C++11) (C++11)	berechnet Quadratwurzel ( $\sqrt x$ ) (Funktion)
cbrt cbrtf cbrtl (C++11) (C++11) (C++11)	berechnet Kubikwurzel ( $3 \sqrt x$ ) (Funktion)
hypot hypotf hypotl (C++11) (C++11) (C++11)	berechnet Hypotenuse $\sqrt x 2 +y 2$ und $\sqrt x 2 +y 2 +z 2$ (seit C++17) (Funktion)
pow (std::complex)	komplexe Potenz, ein oder beide Argumente können komplexe Zahlen sein (Funktionstemplate)
pow (std::valarray)	wendet die Funktion std::pow auf zwei Valarrays oder ein Valarray und einen Wert an (Funktionstemplate)
C-Dokumentation für pow

Compiler support
Freestanding and hosted
Language
Standard library
Standard library headers
Named requirements
Feature test macros (C++20)
Language support library
Concepts library (C++20)
Diagnostics library
Memory management library
Metaprogramming library (C++11)
General utilities library
Containers library
Iterators library
Ranges library (C++20)
Algorithms library
Strings library
Text processing library
Numerics library
Date and time library
Input/output library
Filesystem library (C++17)
Concurrency support library (C++11)
Execution control library (C++26)
Technical specifications
Symbols index
External libraries

cppreference.net

Namespaces

Variants