Perché è complessa < double > * int non definito in C ++?
-
10-07-2019 - |
Domanda
Il programma C ++
#include <complex>
#include <iostream>
int main()
{
std::complex<double> z(0,2);
int n = 3;
std::cout << z * n << std::endl;
}
genera un errore: nessuna corrispondenza per & # 8216; operatore * & # 8217; in & # 8216; z * n & # 8217 ;. Perché?
Sto compilando con g ++ 4.4.1. Forse il compilatore sta solo seguendo lo standard C ++, nel qual caso la mia domanda è: perché lo standard non lo consente?
Soluzione
Funziona:
#include <complex>
#include <iostream>
int main()
{
std::complex<double> z(0,2);
double n = 3.0; // Note, double
std::cout << z * n << std::endl;
}
Poiché il complesso è composto da doppi, si moltiplica con doppi. Guardando la dichiarazione:
template <typename T>
inline complex<T> operator*(const complex<T>&, const T&);
(Ciò che segue è dribeas ) Il compilatore non è autorizzato a effettuare conversioni di tipo implicite durante la detrazione del modello, quindi passando un complesso
con T essendo doppio
, e quindi un altro T essendo int
, quando si tenta di abbinare la funzione trattando T come double
, il secondo argomento non corrisponde correttamente e viceversa.
Per quello che vuoi lavorare, dovrebbe avere una funzione definita simile a questa:
template <typename T, typename U>
inline std::complex<T> operator*(std::complex<T> lhs, const U& rhs)
{
return lhs *= rhs;
}
Che consente alla funzione di assumere tipi diversi, che consente di eseguire il cast quando si chiama operator * =
.
Altri suggerimenti
?? std :: complex < T >
sono definiti per prendere come argomenti altre istanze complex < T >
. Il percorso da un int
tramite un double
a un complex < double >
è solo leggermente contorto / contorto per il linguaggio C ++ per seguirlo secondo allo standard (e con le enormi complicazioni già derivanti dalle conversioni a ruota libera e dalle coerenze è difficile criticare quell'aspetto dello standard). Immagino che il caso super-speciale di complex < double >
che consenta int
come gli operandi ai suoi operatori non sia stato ritenuto abbastanza frequente e abbastanza importante da giustificare la specifica di specializzazioni di template per quello caso estremamente individuale, considerando quanto sia banalmente facile per il programmatore trasmettere int
a double
quando è quello che in realtà vogliono ! -)