Namespaces
Variants

std:: log, std:: logf, std:: logl

From cppreference.net
C++
Numerics library
Common mathematical functions
Nearest integer floating point operations
(C++11)
(C++11)
(C++11) (C++11) (C++11)
Floating point manipulation functions
(C++11) (C++11)
(C++11)
(C++11)
Classification and comparison
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
Types
(C++11)
(C++11)
(C++11)
Macro constants
Definiert in Header <cmath>
(1)
float log ( float num ) ;

double log ( double num ) ;

long double log ( long double num ) ;
(bis C++23)
/*floating-point-type*/
log ( /*floating-point-type*/ num ) ;
(seit C++23)
(constexpr seit C++26)
float logf ( float num ) ;
(2) (seit C++11)
(constexpr seit C++26)
long double logl ( long double num ) ;
(3) (seit C++11)
(constexpr seit C++26)
SIMD-Überladung (seit C++26)
Definiert in Header <simd>
template < /*math-floating-point*/ V >

constexpr /*deduced-simd-t*/ < V >

log ( const V & v_num ) ;
(S) (seit C++26)
Definiert in Header <cmath>
template < class Integer >
double log ( Integer num ) ;
(A) (constexpr seit C++26)
1-3) Berechnet den natürlichen Logarithmus (Basis e ) von num . Die Bibliothek stellt Überladungen von std::log für alle cv-unqualifizierten Gleitkommatypen als Typ des Parameters bereit. (since C++23)
S) Die SIMD-Überladung führt eine elementweise std::log -Operation auf v_num durch.
(Siehe math-floating-point und deduced-simd-t für deren Definitionen.)
(seit C++26)
A) Zusätzliche Überladungen werden für alle Ganzzahltypen bereitgestellt, die als double behandelt werden.
(since C++11)

Inhaltsverzeichnis

Parameter

num - Gleitkomma- oder Ganzzahlwert

Rückgabewert

Wenn keine Fehler auftreten, wird der natürliche (Basis- e ) Logarithmus von num ( ln(num) oder log e (num) ) zurückgegeben.

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

Wenn ein Polfehler auftritt, -HUGE_VAL , -HUGE_VALF , oder -HUGE_VALL wird zurückgegeben.

Fehlerbehandlung

Fehler werden gemeldet, wie in math_errhandling spezifiziert.

Ein Domänenfehler tritt auf, wenn num kleiner als Null ist.

Polfehler kann auftreten, wenn num null ist.

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

  • Wenn das Argument ±0 ist, wird -∞ zurückgegeben und FE_DIVBYZERO wird ausgelöst.
  • Wenn das Argument 1 ist, wird +0 zurückgegeben.
  • Wenn das Argument negativ ist, wird NaN zurückgegeben und FE_INVALID wird ausgelöst.
  • Wenn das Argument +∞ ist, wird +∞ zurückgegeben.
  • Wenn das Argument NaN ist, wird NaN zurückgegeben.

Hinweise

Die zusätzlichen Überladungen müssen nicht exakt wie in (A) bereitgestellt werden. Sie müssen lediglich sicherstellen, dass für ihr Argument num vom Ganzzahltyp, std :: log ( num ) die gleiche Wirkung hat wie std :: log ( static_cast < double > ( num ) ) .

Beispiel

Diesen Code ausführen 
#include <cerrno>
#include <cfenv>
#include <cmath>
#include <cstring>
#include <iostream>
// #pragma STDC FENV_ACCESS ON
int main()
{
    std::cout << "log(1) = " << std::log(1) << '\n'
              << "base-5 logarithm of 125 = " << std::log(125) / std::log(5) << '\n';
    // special values
    std::cout << "log(1) = " << std::log(1) << '\n'
              << "log(+Inf) = " << std::log(INFINITY) << '\n';
    // error handling
    errno = 0;
    std::feclearexcept(FE_ALL_EXCEPT);
    std::cout << "log(0) = " << std::log(0) << '\n';
    if (errno == ERANGE)
        std::cout << "    errno == ERANGE: " << std::strerror(errno) << '\n';
    if (std::fetestexcept(FE_DIVBYZERO))
        std::cout << "    FE_DIVBYZERO raised\n";
}

Mögliche Ausgabe: 

log(1) = 0
base-5 logarithm of 125 = 3
log(1) = 0
log(+Inf) = inf
log(0) = -inf
    errno == ERANGE: Numerical result out of range
    FE_DIVBYZERO raised

Siehe auch

(C++11) (C++11)
berechnet den dekadischen Logarithmus (Basis 10 ) ( log 10 (x) )
(Funktion)
(C++11) (C++11) (C++11)
Logarithmus zur Basis 2 der gegebenen Zahl ( log 2 (x) )
(Funktion)
(C++11) (C++11) (C++11)
natürlicher Logarithmus (zur Basis e ) von 1 plus der gegebenen Zahl ( ln(1+x) )
(Funktion)
(C++11) (C++11)
gibt e hoch der gegebenen Potenz zurück ( e x )
(Funktion)
komplexer natürlicher Logarithmus mit Verzweigungsschnitten entlang der negativen reellen Achse
(Funktions-Template)
wendet die Funktion std::log auf jedes Element des Valarray an
(Funktions-Template)
C-Dokumentation für log