J'ai été créé la fonction de modèle pour vérifier le minimum entre trois types de données différents qui sont (int, float et char) Je pense que mon code est assez bon mais quand il s'agit de l'exécuter, il dit invalide opérandes de types 'float' et 'int' vers l'opérateur binaire% Je ne sais pas quoi faire dans ce cas, mon code est:
#include <iostream>
#include <math.h>
using namespace std;
template <class type>
type mini(type a , type b)
{
type x;
x = fmod(a,b);
if (x ==0)
{
cout<<"it is an even";
return x;
}
else
cout<<"it is an odd";
return x;
}
int main()
{
cout<<"Enter an integer:";
int a,b;
cin>>a>>b;
mini <int> (a,b);
cout<<"\n";
cout<<"Enter a character:";
char x,y;
cin>>x>>y;
mini <char> (x,y);
cout<<"\n";
cout<<"Enter a floating pointing:";
float c,d;
cin>>c>>d;
mini <float> (c,d);
cout<<"\n";
return 0;
}
J'ai mis à jour le code, est-ce correct ?
3 Réponses :
L'opérateur module (%) ne fonctionne pas avec double ou float .
Vous pouvez créer une spécialisation de la fonction et utiliser fmod () / fmodf () à la place.
Attention cependant à ne pas comparer des nombres à virgule flottante avec 0 .
template<> float mini(float a, float b) ...
mais je teste mon programme avec ("float, int, and char")
Je le modifie mais je ne travaille toujours pas pour la fonction de modèle pour vérifier si c'est pair ou impair
Je le modifie mais je ne travaille toujours pas pour la fonction de modèle pour vérifier si c'est pair ou impair
Optez pour fmod car le double n'a pas l'opérateur% implémenté.
Le lien ci-dessous peut vous aider: erreur C2296: '%': l'opérande gauche illégal a tapez 'double' en C ++
Faire cela avec des virgules flottantes est un peu délicat car il n'y a aucune garantie que le reste d'une division avec 2 se traduira par exactement 0 même pour les nombres entrés qui sont clairement pairs. En outre, les nombres que vous saisissez peuvent ne pas être stockés exactement tels que vous les avez saisis, ce qui peut également modifier la caractéristique paire / impaire. Epsilon peut aider dans certains cas, mais il se contentera de > 0 ici:
Enter two ints:The int 4 is even Enter two chars:The int a is odd Enter two floats:The float 4 is even Enter two doubles:The float 4.0000001000000002804 is odd Enter two floats again:The float 6666666496 is even
Sortie possible:
#include <iostream>
#include <cmath>
#include <type_traits>
#include <limits>
#include <sstream>
#include <iomanip>
// the function template for integer types
template <class type, std::enable_if_t<std::is_integral_v<type>, int> = 0>
type mini(type a, type b)
{
auto min = std::min(a, b);
if(min%2) std::cout << "The int " << min << " is odd\n";
else std::cout << "The int " << min << " is even\n";
return min;
}
// the function template for floating point types
template<class type, std::enable_if_t<std::is_floating_point_v<type>, int> = 0>
type mini(type a, type b) {
auto min = std::min(a, b);
// do the floating point modulus operation
auto mod = std::abs(std::fmod(min, type{2}));
// check if it's bigger than a default initialized "type" (0.f or 0.)
if(mod > type{}) // std::numeric_limits<type>::epsilon())
std::cout << "The float " << min << " is odd\n";
else
std::cout << "The float " << min << " is even\n";
return min;
}
// the rest is just for testing
std::istringstream cin(
"5 4\n"
"a b\n"
"6.1 4.0000002\n" // float - even, stored as 4
"6.1 4.0000001\n" // double - odd, has enough precision
"6666666653 6666666653\n" // float - looks odd, right? Probably not...
);
template<typename type>
void enter(const char* txt) {
type a, b;
std::cout << "Enter two " << txt << ':';
if(cin >> a >> b)
mini(a, b);
}
int main()
{
std::cout << std::setprecision(20);
enter<int>("ints");
enter<char>("chars");
enter<float>("floats");
enter<double>("doubles");
enter<float>("floats again");
}