Perché il complesso è <double> * int non definito in C++?

Question

Il programma

#include <complex> 
#include <iostream> 

int main() 
{ 
    std::complex<double> z(0,2); 
    int n = 3; 
    std::cout << z * n << std::endl; 
} 

C++ produce un errore: non può competere ‘operatore *’ a ‘z * n’. 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?

Answer 1

Questo 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; 
} 

Perché complesso si compone di doppi, si moltiplica con doppie. Guardando la dichiarazione:

template <typename T> 
inline complex<T> operator*(const complex<T>&, const T&); 

(Il seguente è grazie a dribeas) Il compilatore non è consentito effettuare conversioni di tipo implicite nel modello deduzione, così facendo passare un complex con T essendo double, e poi un altro T è int, quando si cerca di far corrispondere la funzione che tratta T come double causa la corrispondenza errata del secondo argomento e viceversa.

Per quello che si desidera lavorare, si dovrebbe avere una funzione definita simile a questo:

template <typename T, typename U> 
inline std::complex<T> operator*(std::complex<T> lhs, const U& rhs) 
{ 
    return lhs *= rhs; 
} 

che permette la funzione di prendere tipi diversi, che permette il cast da compiere quando si chiama operator*=.

Answer 2

std::complex<T> Gli operatori sono definiti per prendere come argomenti altre istanze complex<T>. Il percorso da uno a complex<double> è leggermente troppo contorto/convoluto per il linguaggio C++ per seguirlo secondo lo standard (e con le enormi complicazioni già derivanti dalle conversioni e dalle coerenze a ruota libera è difficile criticare lo che aspetto dello standard). Immagino che il caso super-speciale di complex<double> che consente gli int s non trasmessi come operandi ai suoi operatori non sia stato ritenuto abbastanza frequente e importante da giustificare la specificazione dei modelli per quel caso estremamente individuale, considerando quanto sia facile per il programmatore trasmettere il int a double quando questo è quello che in realtà vogliono -!)