Déterminer quel est le type de typedef

Question

Je veux utiliser quelque chose pour l'infini positif. Cependant, le type de données que mon code utilise est typedef'ed par la classe d'autres personnes. Cela veut dire qu'il peut y avoir un int, un float, un double et des types assez numériques.

Précédemment, quand j'utilisais l'infini, je voudrais quelque chose comme INT_MAX pour les entiers et ainsi de suite. Cependant, puis-je déterminer (au compiler) le type que j'utilise?

J'ai trouvé this réponse, mais je ne pense pas que ce soit ce que je cherche.

Mais d'un autre côté, je ne peux pas penser à une méthode élégante pour y parvenir.

Dans le code:

typedef float FT; 

// in another file 
//if FT is int 
int inf = INT_MAX; 

... 

//if FT is float 
float inf = FLOAT_MAX; 

Mais encore, ce ne serait pas bien, parce que je veux passer comme paramètre à une fonction. Quelle serait la signature de la fonction est le premier problème qui vient à l'esprit.

[EDIT]

La signature pourrait utiliser le typedef.

Answer 1

Peut-être que vous pourriez vérifier numeric_limits<T>.

// numeric_limits example 
#include <iostream>  // std::cout 
#include <limits>  // std::numeric_limits 

typedef float FT; 

int main() { 
    std::cout << std::boolalpha; 
    std::cout << "Minimum value for FT: " << std::numeric_limits<FT>::min() << '\n'; 
    std::cout << "Maximum value for FT: " << std::numeric_limits<FT>::max() << '\n'; 
    std::cout << "FT is signed: " << std::numeric_limits<FT>::is_signed << '\n'; 
    std::cout << "Non-sign bits in FT: " << std::numeric_limits<FT>::digits << '\n'; 
    std::cout << "FT has infinity: " << std::numeric_limits<FT>::has_infinity << '\n'; 
    return 0; 
} 

Avec typedef float FT;

Minimum value for FT: 1.17549e-38 
Maximum value for FT: 3.40282e+38 
FT is signed: true 
Non-sign bits in FT: 24 
FT has infinity: true 

Avec typedef int FT;

Minimum value for FT: -2147483648 
Maximum value for FT: 2147483647 
FT is signed: true 
Non-sign bits in FT: 31 
FT has infinity: false 

Answer 2

Vous pouvez interroger le type à l'exécution en utilisant l'opérateur typeid. Cependant, cela ne résoudra pas votre problème. Si tout ce que vous voulez est le nombre le plus positif qu'un type peut contenir, utilisez std::numeric_limits<FT>::max(). Notez qu'il existe également std::numeric_limits<FT>::has_quiet_NaN(). Ce sont des essions à la compilation, ce qui les rend vraiment utiles.

Answer 3

Utilisez std::numeric_limits.

#include <limits> 
#include <type_traits> 

template <typename T, typename enable_if_helper = void> 
struct get_infinity_helper; 

template <typename T> 
struct get_infinity_helper<T, typename std::enable_if<std::numeric_limits<T>::has_infinity>::type> 
{ 
    static constexpr T infinity = std::numeric_limits<T>::infinity(); 
}; 

template <typename T> 
struct get_infinity_helper<T, typename std::enable_if<!std::numeric_limits<T>::has_infinity>::type> 
{ 
    static constexpr T infinity = std::numeric_limits<T>::max(); 
}; 

Ensuite, utilisez get_infinity_helper<T>::infinity.