C++-Standardbibliothek`<numbers>`

Vor C++20 schrieben wir mathematische Konstanten normalerweise so:

const double PI = 3.14159265358979323846;

Das Problem ist sehr offensichtlich:Präzision wurde willkürlich, inkonsistent, fehleranfällig und nicht typsicher geschrieben./p>

C++20 führte offiziell#include <numbers>ein, wodurch eine standardisierte Menge mathematischer Konstanten bereitgestellt wird, wobei Präzision und Typkorrektheit vom Compiler garantiert werden.

std::numbersEs ist ein in C++20 eingeführtes Standardbibliotheksmodul, das hauptsächlich dazu dient, eine Reihe häufig verwendeter mathematischer Konstanten bereitzustellen, und als Standardablage für mathematische und physikalische Konstanten dient.

std::numbersBefindet sich in<numbers>in der Header-Datei und enthält viele mathematische Konstanten, darunter gängige Konstanten wie Pi, die Basis des natürlichen Logarithmus, der Goldene Schnitt usw.

Die Verwendung dieser Konstanten in C++ kann die Lesbarkeit, Präzision und Effizienz des Codes verbessern und wiederholte Definitionen sowie die manuelle Eingabe von Konstantenwerten vermeiden.

std::numbersVorteile im Vergleich zur traditionellen Schreibweise:

Dimension	Traditioneller Ansatz	`<numbers>`
Precision	Ad hoc	Standardmäßig hohe Präzision
Type	Festgelegt	Automatische Anpassung
Lesbarkeit	Durchschnittlich	Klare Semantik
Kompilierzeitkonstante	Nicht unbedingt	Definitiv
Standardisierung	Schlecht	Standardbibliotheksebene

Im Modul std::numbers enthaltene Konstanten

Der Namespace std::numbers enthält die folgenden Member:

template<floating_point T> inline constexpr T e_v<T> // 自然常数e
template<floating_point T> inline constexpr T log2e_v<T> // log2e
template<floating_point T> inline constexpr T log10e_v<T> // log10e
template<floating_point T> inline constexpr T pi_v<T> // 圆周率π
template<floating_point T> inline constexpr T inv_pi_v<T> // 1/π
template<floating_point T> inline constexpr T inv_sqrtpi_v<T> //1/根号π
template<floating_point T> inline constexpr T ln2_v<T> // ln2
template<floating_point T> inline constexpr T ln10_v<T> // ln10
template<floating_point T> inline constexpr T sqrt2_v<T> //根号2
template<floating_point T> inline constexpr T sqrt3_v<T> //根号3
template<floating_point T> inline constexpr T inv_sqrt3_v<T> // 1/根号3
template<floating_point T> inline constexpr T egamma_v<T> // 欧拉常数γ
template<floating_point T> inline constexpr T phi_v<T> // 黄金分割比Φ
inline constexpr double e = e_v<double>
inline constexpr double log2e = log2e_v<double>
inline constexpr double log10e = log10e_v<double>
inline constexpr double pi = pi_v<double>
inline constexpr double inv_pi = pi_v<double>
inline constexpr double inv_sqrtpi = pi_v<double>
inline constexpr double ln2 = ln2_v<double>
inline constexpr double ln10 = ln10_v<double>
inline constexpr double sqrt2 = sqrt2_v<double>
inline constexpr double sqrt3 = sqrt3_v<double>
inline constexpr double inv_sqrt3 = sqrt3_v<double>
inline constexpr double egamma = egamma_v<double>
inline constexpr double phi = phi_v<double>

Das Folgende ist eine Liste der in std::numbers enthaltenen Konstanten:

Konstanten-/Template-Name	Beschreibung	Beispielwerte (ungefähr)
`e_v`	Mathematische Konstante e (Basis der natürlichen Logarithmen)	`2.718281828459045`
`log2e_v`	Logarithmus von e zur Basis 2 (log₂(e))	`1.4426950408889634`
`log10e_v`	Logarithmus von e zur Basis 10 (log₁₀(e))	`0.4342944819032518`
`pi_v`	Mathematische Konstante π (pi)	`3.141592653589793`
`inv_pi_v`	1/π (der Kehrwert von π)	`0.318309886183121`
`inv_sqrtpi_v`	1/√π (der Kehrwert der Quadratwurzel aus π)	`0.5641895835477563`
`ln2_v`	Natürlicher Logarithmus von 2 (ln(2))	`0.6931471805599453`
`ln10_v`	Natürlicher Logarithmus von 10 (ln(10))	`2.302585092994046`
`sqrt2_v`	√2 (Quadratwurzel aus 2)	`1.4142135623730951`
`sqrt3_v`	√3 (Quadratwurzel aus 3)	`1.7320508075688772`
`inv_sqrt3_v`	1/√3 (der Kehrwert der Quadratwurzel aus 3)	`0.5773502691896257`
`egamma_v`	Euler-Mascheroni-Konstante γ	`0.5772156649015329`
`phi_v`	Goldener Schnitt Φ ((1 + √5) / 2)	`1.618033988749895`
`e`	Konstante e (entspricht`e_v<double>`)	`2.718281828459045`
`log2e`	Konstante log₂(e) (entspricht`log2e_v<double>`)	`1.4426950408889634`
`log10e`	Konstante log₁₀(e) (entspricht`log10e_v<double>`)	`0.4342944819032518`
`pi`	Konstante π (entspricht`pi_v<double>`)	`3.141592653589793`
`inv_pi`	Konstante 1/π (entspricht`inv_pi_v<double>`)	`0.318309886183121`
`inv_sqrtpi`	Konstante 1/√π (entspricht`inv_sqrtpi_v<double>`)	`0.5641895835477563`
`ln2`	Konstante ln(2) (entspricht`ln2_v<double>`)	`0.6931471805599453`
`ln10`	Konstante ln(10) (entspricht`ln10_v<double>`)	`2.302585092994046`
`sqrt2`	Konstante √2 (entspricht`sqrt2_v<double>`)	`1.4142135623730951`
`sqrt3`	Konstante √3 (entspricht`sqrt3_v<double>`)	`1.7320508075688772`
`inv_sqrt3`	Konstante 1/√3 (entspricht`inv_sqrt3_v<double>`)	`0.5773502691896257`
`egamma`	Konstante γ (Euler-Mascheroni-Konstante) (entspricht`egamma_v<double>`)	`0.5772156649015329`
`phi`	Konstante Goldener Schnitt Φ (entspricht`phi_v<double>`)	`1.618033988749895`

Diese Konstanten und Variablentemplates decken häufig verwendete mathematische Konstanten wie pi, die Basis des natürlichen Logarithmus und den goldenen Schnitt ab und bieten Präzisionsoptionen durch Variablentemplates verschiedener Typen wie float, double und long double.

Beispiel

#include <iostream>
#include <iomanip>
#include <numbers>
#include <cmath> // für Standard-Mathematikfunktionen sin, cos, log usw.

using namespace std;

int main()
{
// Konstanten mit Standardtyp double verwenden
cout << fixed << setprecision(15); // Alle Ausgaben auf 15 Dezimalstellen setzen

// Den Wert von π (pi) ausgeben
cout << "Der Wert von pi ist: " << numbers::pi << endl;

// Den Wert von e ausgeben (Basis des natürlichen Logarithmus)
cout << "Der Wert der natürlichen Konstante e ist: " << numbers::e << endl;

// Den Wert der Quadratwurzel von 2 (sqrt2) ausgeben
cout << "Der Wert der Quadratwurzel von 2 (sqrt2) ist: " << numbers::sqrt2 << endl;

// Den Wert der Quadratwurzel von 3 (sqrt3) ausgeben
cout << "Der Wert der Quadratwurzel von 3 (sqrt3) ist: " << numbers::sqrt3 << endl;

// Gibt den Wert des Goldenen Schnitts phi aus
cout << "Der Wert des Goldenen Schnitts phi ist: " << numbers::phi << endl;

// Gibt den Wert der Euler-Mascheroni-Konstante egamma aus
cout << "Der Wert der Euler-Mascheroni-Konstante egamma ist: " << numbers::egamma << endl;

// Gibt den Wert von 1/π (inv_pi) aus
cout << "Der Wert von 1/π (inv_pi) ist: " << numbers::inv_pi << endl;

// Gibt den Wert von 1/√π (inv_sqrtpi) aus
cout << "Der Wert von 1/√π (inv_sqrtpi) ist: " << numbers::inv_sqrtpi << endl;

// Gibt den Wert von log2e, dem Logarithmus zur Basis 2 von e, aus
cout << "Der Wert von log2e, dem Logarithmus zur Basis 2 von e, ist: " << numbers::log2e << endl;

// Gibt den Wert von log10e, dem Logarithmus zur Basis 10 von e, aus
cout << "Der Wert von log10e, der Logarithmus zur Basis 10 von e, ist: " << numbers::log10e << endl;

// Den Wert von sin(π/2) ausgeben
cout << "Der Wert von sin(π/2) ist: " << sin(numbers::pi / 2) << endl;

// Den Wert von cos(π) ausgeben
cout << "Der Wert von cos(π) ist: " << cos(numbers::pi) << endl;

// Den Wert von ln(e) ausgeben
cout << "Der Wert von ln(e) ist: " << log(numbers::e) << endl;

// Die Verwendung verschiedener Datentypen demonstrieren
float pi_f = numbers::pi_v<float>; // pi vom Typ float verwenden
cout << "\npi vom Typ float verwenden: " << setprecision(7) << pi_f << endl; // 7 Dezimalstellen ausgeben

long double pi_ld = numbers::pi_v<long double>; // Verwende pi vom Typ long double
cout << "Pi vom Typ long double verwenden: " << setprecision(21) << pi_ld << endl; // 21 Nachkommastellen ausgeben

// Werte mit unterschiedlichen Genauigkeiten berechnen
cout << "\nsin(π/2) mit double: " << sin(numbers::pi / 2) << endl;
cout << "sin(π/2) mit float: " << sin(static_cast<float>(numbers::pi) / 2) << endl;
cout << "sin(π/2) mit long double: " << sin(static_cast<long double>(numbers::pi) / 2) << endl;

return 0;
}

Codeanalyse:

Formatierte Ausgabe:

Nutzungfixedundsetprecision()um eine feste Anzahl von Nachkommastellen in der Ausgabe sicherzustellen. Hier werden standardmäßig 15 Nachkommastellen ausgegeben, aber für jeden unterschiedlichen Datentyp kann auch eine andere Genauigkeit festgelegt werden.

Berechnen Sie gängige mathematische Funktionen:

berechnetsin(π/2)、cos(π)undln(e)und andere gängige mathematische Funktionen und verwenden SiecmathFunktionen in (zum Beispielsin、cosundlog), um zu zeigen, wie mathematische Konstanten verwendet werden.

Präzision für verschiedene Datentypen:

Nutzungnumbers::pi_v<float>undnumbers::pi_v<long double>um verschiedene Arten von Konstanten zu demonstrieren. Fürfloatundlong double, können Sie mit unterschiedlicher Präzision ausgeben.

Berechnungen mit verschiedenen Typen:

Beim Berechnensinwenn ..., zeigt es, wie Berechnungen mit Typen unterschiedlicher Präzision durchgeführt werden, und veranschaulichtfloat、doubleundlong doubleUnterschiede unter demselben mathematischen Ausdruck.

Ausgabe:

圆周率 pi 的值是: 3.141592653589793
自然常数 e 的值是: 2.718281828459045
根号2 (sqrt2) 的值是: 1.414213562373095
根号3 (sqrt3) 的值是: 1.732050807568877
黄金比例 phi 的值是: 1.618033988749895
欧拉-马歇罗尼常数 egamma 的值是: 0.5772156649015329
1/π (inv_pi) 的值是: 0.318309886183121
1/√π (inv_sqrtpi) 的值是: 0.5641895835477563
以 2 为底的 e 的对数 log2e 的值是: 1.4426950408889634
以 10 为底的 e 的对数 log10e 的值是: 0.4342944819032518
sin(π/2) 的值是: 1
cos(π) 的值是: -1
ln(e) 的值是: 1

使用 float 类型的 pi: 3.1415927
使用 long double 类型的 pi: 3.141592653589793238462643
sin(π/2) 使用 double: 1
sin(π/2) 使用 float: 1
sin(π/2) 使用 long double: 1

Anwendungsbeispiele

Die folgenden Beispiele behandeln<numbers>die am häufigsten verwendeten Konstanten; der Code kann direkt kompiliert und ausgeführt werden. Denken Sie daran, einen Standardparameter-std=c++20 hinzuzufügen：

g++ -std=c++20 main.cpp -o main

Beispiel 1: Grundlegende Verwendung

Berechnung der Fläche / des Umfangs eines Kreises mit π:

Beispiel

#include <iostream>
#include <numbers> // enthält mathematische Konstanten
#include <cmath> // enthält mathematische Funktionen wie pow

using namespace std;
using namespace std::numbers; // Vereinfacht Konstantenaufrufe (optional)

int main() {
// Der Radius des Kreises
double r = 5.0;

// 1. Umfang des Kreises berechnen: 2 * π * r
double circumference = 2 * pi * r; // π direkt mit doppelter Genauigkeit verwenden
cout << "Radius ist " << r << ", Umfang: " << circumference << endl; // Ausgabe: 31.4159

// 2. Fläche des Kreises berechnen: π * r²
double area = pi * pow(r, 2);
cout << "Radius ist " << r << ", Fläche: " << area << endl; // Ausgabe: 78.5398

// 3. Version mit hoher Genauigkeit (long double)
long double r_ld = 5.0L;
long double area_ld = pi_v<long double> * powl(r_ld, 2); // powl ist die long double-Version von pow
cout << "Kreisfläche mit hoher Genauigkeit: " << area_ld << endl; // Gibt eine genauere 78.53981633974483... aus

return 0;
}

Beispiel 2: Konstante e

Natürliche Konstante e und Exponentialberechnungen:

Beispiel

#include <iostream>
#include <numbers>
#include <cmath>

using namespace std;
using namespace std::numbers;

int main() {
// Natürliche Exponentialberechnung: e^x (die Funktion exp ist die Exponentialfunktion in cmath)
double x = 2.0;
double exp_result = exp(x); // e^2 manuell berechnen
double exp_result_direct = pow(e, x); // e^2 mit numbers::e berechnen
cout << "e^2 = " << exp_result << endl; // Ausgabe: 7.38906
cout << "e^2 (direkte Berechnung) = " << exp_result_direct << endl; // Ergebnisse sind konsistent

return 0;
}

Beispiel 3: Goldener Schnitt

Anwendung des Goldenen Schnitts φ:

Beispiel

#include <iostream>
#include <numbers>

using namespace std;
using namespace std::numbers;

int main() {
// Goldener Schnitt: wenn Länge/Breite = φ, ist es ein goldenes Rechteck
double width = 10.0;
double golden_height = width * phi; // Höhe des goldenen Rechtecks
cout << "Breite ist " << width << ", die Höhe des goldenen Rechtecks: " << golden_height << endl; // Ausgabe: 16.1803

// Mathematische Definition von φ überprüfen: φ = (1 + √5)/2
double phi_manual = (1 + sqrt(5.0)) / 2;
cout << "Manuell berechneter Goldener Schnitt: " << phi_manual << endl; // Konsistent mit numbers::phi

return 0;
}

Beispiel 4: Gleitkommatypen

Anpassung der Konstanten für verschiedene Gleitkommatypen:

Beispiel

#include <iostream>
#include <numbers>
#include <iomanip> // dient zum Festlegen der Ausgabegenauigkeit

using namespace std;

int main() {
// Ausgabe mit hoher Genauigkeit einstellen (15 Dezimalstellen anzeigen)
cout << fixed << setprecision(15);

// float-Version von π (einfache Genauigkeit)
float pi_float = std::numbers::pi_v<float>;
cout << "float π: " << pi_float << endl; // Ausgabe: 3.141592741012573

// double-Version von π (doppelte Genauigkeit, Standard)
double pi_double = std::numbers::pi;
cout << "double π: " << pi_double << endl; // Ausgabe: 3.141592653589793

// Version von π als long double (hohe Genauigkeit)
long double pi_long_double = std::numbers::pi_v<long double>;
cout << "long double π: " << pi_long_double << endl; // Gibt den genaueren Wert 3.1415926535897932385... aus

return 0;
}

Weitere Erweiterungen

C++ Objektorientierung

C++ Fortgeschrittene Tutorials

C++ Ressourcenbibliothek

C++-Standardbibliothek`<numbers>`

Im Modul std::numbers enthaltene Konstanten

Beispiel

Anwendungsbeispiele

Beispiel 1: Grundlegende Verwendung

Beispiel

Beispiel 2: Konstante e

Beispiel

Beispiel 3: Goldener Schnitt

Beispiel

Beispiel 4: Gleitkommatypen

Beispiel

C++ Objektorientierung

C++ Fortgeschrittene Tutorials

C++ Ressourcenbibliothek

C++-Standardbibliothek<numbers>

Im Modul std::numbers enthaltene Konstanten

Beispiel

Anwendungsbeispiele

Beispiel 1: Grundlegende Verwendung

Beispiel

Beispiel 2: Konstante e

Beispiel

Beispiel 3: Goldener Schnitt

Beispiel

Beispiel 4: Gleitkommatypen

Beispiel

C++-Standardbibliothek`<numbers>`