Moltiplicando complesso con costante C ++
-
27-09-2019 - |
Domanda
Il seguente codice non riesce a compilare
#include <iostream>
#include <cmath>
#include <complex>
using namespace std;
int main(void)
{
const double b=3;
complex <double> i(0, 1), comp;
comp = b*i;
comp = 3*i;
return 0;
}
con di errore: non è partita per ‘operatore *’ in ‘3 * i’ Cosa c'è di sbagliato qui, perché non posso moltiplicare con le costanti immediati? b * i funziona.
Soluzione
Nella prima riga:
comp = b*i;
Le chiamate compilatore:
template<class T> complex<T> operator*(const T& val, const complex<T>& rhs);
Che viene istanziato come:
template<> complex<double> operator*(const double& val, const complex<double>& rhs);
Nel secondo caso, non v'è alcun modello appropriato int
, in modo che l'istanze fallisce:
comp = 3.0 * i; // no operator*(int, complex<double>)
Altri suggerimenti
http://www.cplusplus.com/reference/std / complesso / complesso / operatori / per una panoramica degli operatori complessi.
Si noterà che l'operatore * è un modello e utilizzerà il parametro di modello della classe complesso per generare quel codice. Il numero letterale si utilizza per richiamare operatore * è di tipo int. Utilizzare comp = 3. * i;
la classe std::complex
è un po 'stupido ... definire questi per consentire le promozioni automatiche:
// Trick to allow type promotion below
template <typename T>
struct identity_t { typedef T type; };
/// Make working with std::complex<> nubmers suck less... allow promotion.
#define COMPLEX_OPS(OP) \
template <typename _Tp> \
std::complex<_Tp> \
operator OP(std::complex<_Tp> lhs, const typename identity_t<_Tp>::type & rhs) \
{ \
return lhs OP rhs; \
} \
template <typename _Tp> \
std::complex<_Tp> \
operator OP(const typename identity_t<_Tp>::type & lhs, const std::complex<_Tp> & rhs) \
{ \
return lhs OP rhs; \
}
COMPLEX_OPS(+)
COMPLEX_OPS(-)
COMPLEX_OPS(*)
COMPLEX_OPS(/)
#undef COMPLEX_OPS