L'opérateur de modèle C++ donne un mauvais résultat en soustrayant un scalaire d'un vecteur

Question

J'essaie de faire une fonction d'opérateur de modèle pour soustraire un scalaire d'un vecteur et retourner le résultat dans un vecteur. La fonction ci-dessous est ce que je suis en mesure de venir avec:

// vector - scalar 
template<typename T1, typename T2> 
auto operator - (const Vector<T1> & lhs, const T2 & scalar)-> Vector<std::common_type_t<T1,T2>> 
{ 
    using T3 = std::common_type_t<T1, T2>; 
    Vector<T3> result; 
    result.base.reserve(lhs.base.size()); 
    std::transform(lhs.base.begin(), lhs.base.end(), std::back_inserter(result.base), 
      [&scalar](const T3 & element) { return element - scalar; }); 
    return result; 
} 

Cependant, le résultat est pas correct, en essayant de soustraire un scalaire (float) à partir d'un vecteur (int). Je suspecte le problème parce que les opérandes subissent les conversions arithmétiques habituelles, qui incluent promotions intégrales.

DEMO

Answer 1

Cela n'a rien à voir avec les modèles, mais avec le fait que les nombres à virgule flottante ne sont pas exactes.

Cela produit le même « mauvais résultat » vous a spécifiquement cité dans les commentaires:

float subtract(float a, float b) 
{ 
    return a-b; 
} 

int main() 
{ 
    std::cout << subtract(2, 2.1) << std::endl; 

    return 0; 
} 

Essayez de compiler vous-même, et voir ce que le résultat est.

C'est aussi -0,0999999.

Bienvenue dans le monde merveilleux des mathématiques en virgule flottante.

Si vous avez besoin d'une précision mathématique précise, il existe des bibliothèques spécialisées qui l'implémentent.