Pourquoi est complexe < double > * int n'est pas défini en C ++?

Question

Le programme C ++

#include <complex>
#include <iostream>

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

génère une erreur: pas de correspondance pour & # 8216; opérateur * & # 8217; dans & # 8216; z * n & # 8217 ;. Pourquoi?

Je compile avec g ++ 4.4.1. Peut-être que le compilateur ne fait que suivre la norme C ++, auquel cas ma question est: pourquoi la norme ne le permet-elle pas?

Answer 1

Ceci fonctionne:

#include <complex>
#include <iostream>

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

Le complexe étant composé de doubles, il se multiplie par des doubles. En regardant la déclaration:

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

(Ce qui suit revient à dribeas ) Le compilateur n'est pas autorisé à effectuer des conversions de type implicites lors de la déduction de modèle. en passant un complexe avec T en double , puis un autre T en int , lorsque vous essayez de faire correspondre la fonction qui considère T comme double , le second argument ne correspond pas, et vice-versa.

Pour que vous souhaitiez travailler, une fonction similaire à celle-ci devrait être définie:

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

Ce qui permet à la fonction de prendre différents types, ce qui permet d'effectuer la conversion lors de l'appel de opérateur * = .

Answer 2

Les opérateurs de

std :: complex < T > sont définis pour prendre comme arguments d'autres instances complexes < T > . La route d’un int via un double à un complexe < double > est juste marginalement trop contournée / convolutée pour que le langage C ++ puisse le suivre selon à la norme (et avec les énormes complications déjà générées par les conversions et les cohérences en roue libre, il est difficile de critiquer cet aspect de la norme). J'imagine que le cas très spécial de complexes < doubles > permettant des int s non codés comme opérandes à ses opérateurs n'a tout simplement pas été jugé assez fréquent et assez important pour justifier la spécification de spécialisations de gabarits pour celui-ci. cas extrêmement individuel, compte tenu de la facilité triviale pour le programmeur de transtyper int en double , alors que le souhaite réellement ! -)