std::conj(std::complex)

 

C++

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

 

Numerik-Bibliothek

Allgemeine mathematische Funktionen
Mathematische Spezialfunktionen (C++17)
Mathematische Konstanten (C++20)
Grundlegende lineare Algebra-Algorithmen (C++26)
Datenparallele Typen (SIMD) (C++26)
Gleitkomma-Umgebung (C++11)
Komplexe Zahlen
Numerische Arrays (valarray)
Pseudozufallszahlengenerierung
Bit-Manipulation (C++20)
Faktoroperationen
gcd (C++17)	lcm (C++17)
Interpolationen
midpoint (C++20)	lerp (C++20)
Sättigungsarithmetik
add_sat (C++26) sub_sat (C++26) saturate_cast (C++26)	mul_sat (C++26) div_sat (C++26)
Generische numerische Operationen
iota (C++11) ranges::iota (C++23) accumulate inner_product adjacent_difference    partial_sum	reduce (C++17) transform_reduce (C++17) inclusive_scan (C++17) exclusive_scan (C++17) transform_inclusive_scan (C++17) transform_exclusive_scan (C++17)

 

std::complex

Memberfunktionen
complex::complex complex::operator= complex::real complex::imag	complex::operator+=complex::operator-=complex::operator*=complex::operator/=
Nicht-Member-Funktionen
operator+operator- operator+operator-operator*operator/ operator==operator!= (bis C++20)   operator<<operator>> get(std::complex) (C++26)	real imag abs arg norm conj proj (C++11) polar operator""ioperator""ifoperator""il (C++14)(C++14)(C++14)
Exponentialfunktionen
log   log10   exp
Potenzfunktionen
pow   sqrt
Trigonometrische Funktionen
sin   cos tan asin (C++11) acos (C++11) atan (C++11)
Hyperbolische Funktionen
sinh   cosh tanh asinh (C++11) acosh (C++11) atanh (C++11)
Hilfstypen
tuple_size<std::complex> (C++26)
tuple_element<std::complex> (C++26)

 

Definiert in der Header-Datei <complex>
	(1)
template< class T > std::complex<T> conj( const std::complex<T>& z );			(bis C++20)
template< class T > constexpr std::complex<T> conj( const std::complex<T>& z );			(seit C++20)
Zusätzliche Überladungen (seit C++11)
Definiert in der Header-Datei <complex>
		(A)
std::complex<float>       conj( float f ); std::complex<double>      conj( double f ); std::complex<long double> conj( long double f );				(bis C++20)
constexpr std::complex<float>       conj( float f ); constexpr std::complex<double>      conj( double f ); constexpr std::complex<long double> conj( long double f );				(seit C++20) (bis C++23)
template< class FloatingPoint > constexpr std::complex<FloatingPoint> conj( FloatingPoint f );				(seit C++23)
			(B)
template< class Integer > constexpr std::complex<double> conj( Integer i );					(bis C++20)
template< class Integer > constexpr std::complex<double> conj( Integer i );					(seit C++20)

1) Berechnet die komplex Konjugierte von z, indem das Vorzeichen des Imaginärteils umgekehrt wird.

A,B) Zusätzliche Überladungen sind für alle ganzzahligen und Gleitkommatypen vorhanden, die als komplexe Zahlen mit Null-Imaginärteil behandelt werden.

(seit C++11)

Parameter

z	-	komplexer Wert
f	-	Gleitkommawert
i	-	ganzzahliger Wert

Rückgabewert

1) Die komplex Konjugierte von z.

A) std::complex(f).

B) std::complex<double>(i).

Hinweise

Die zusätzlichen Überladungen müssen nicht exakt wie in (A,B) angegeben bereitgestellt werden. Sie müssen nur ausreichen, um sicherzustellen, dass für ihr Argument num

• Wenn num einen Standard(bis C++23) Gleitkommatyp T hat, dann hat std::conj(num) den gleichen Effekt wie std::conj(std::complex<T>(num)).
• Andernfalls, wenn num einen ganzzahligen Typ hat, dann hat std::conj(num) den gleichen Effekt wie std::conj(std::complex<double>(num)).

Beispiel

Führen Sie diesen Code aus

#include <complex>
#include <iostream>
 
int main()
{
    std::complex<double> z(1.0, 2.0);
    std::cout << "The conjugate of " << z << " is " << std::conj(z) << '\n'
              << "Their product is " << z * std::conj(z) << '\n';
}

Ausgabe

The conjugate of (1,2) is (1,-2)
Their product is (5,0)

Siehe auch

abs(std::complex)	gibt den Betrag einer komplexen Zahl zurück (function template)
norm	gibt das Quadrat des Betrags zurück (function template)
polar	konstruiert eine komplexe Zahl aus Betrag und Phasenwinkel (function template)
C-Dokumentation für conj