Comment initialiser un flottant à sa valeur max / min?

Comment coder en dur une valeur maximale ou minimale absolue pour un flottant ou un double? Je veux rechercher le max / min d'un tableau en itérant simplement et en capturant le plus grand.

Il existe également une infinité positive et négative pour les flottants, dois-je les utiliser à la place? Si tel est le cas, comment le désigner dans mon code?

Vous pouvez utiliser std::numeric_limitsce qui est défini dans <limits>pour trouver la valeur minimale ou maximale des types (tant qu'il existe une spécialisation pour le type). Vous pouvez également l'utiliser pour récupérer l'infini (et mettre un -devant pour l'infini négatif).

#include <limits>

//...

std::numeric_limits<float>::max();
std::numeric_limits<float>::min();
std::numeric_limits<float>::infinity();

Comme indiqué dans les commentaires, min()renvoie la valeur positive la plus basse possible. En d'autres termes, la valeur positive la plus proche de 0 qui peut être représentée. La valeur la plus basse possible est la valeur négative de la valeur maximale possible.

Il y a bien sûr les std::max_elementfonctions et min_element (définies dans <algorithm>) qui peuvent être un meilleur choix pour trouver la valeur la plus grande ou la plus petite d'un tableau.

Vous pouvez utiliser -FLT_MAX(ou -DBL_MAX) pour le nombre négatif de magnitude maximale et FLT_MAX(ou DBL_MAX) pour le positif. Cela vous donne la plage de valeurs flottantes (ou doubles) possibles.

Vous ne voulez probablement pas utiliser FLT_MIN; il correspond au plus petit nombre positif de magnitude pouvant être représenté avec un flottant, et non à la valeur la plus négative représentable avec un flottant.

FLT_MINet FLT_MAXcorrespondent à std::numeric_limits<float>::min()et std::numeric_limits<float>::max().

Il n'y a pas vraiment besoin de s'initialiser au plus petit / plus grand possible pour trouver le plus petit / le plus grand du tableau:

double largest = smallest = array[0];
for (int i=1; i<array_size; i++) {
    if (array[i] < smallest)
        smallest = array[i];
    if (array[i] > largest0
        largest= array[i];
}

Ou, si vous le faites plus d'une fois:

#include <utility>

template <class iter>
std::pair<typename iter::value_type, typename iter::value_type> find_extrema(iter begin, iter end) {
    std::pair<typename iter::value_type, typename iter::value_type> ret;
    ret.first = ret.second = *begin;
    while (++begin != end) {
        if (*begin < ret.first)
           ret.first = *begin;
        if (*begin > ret.second)
           ret.second = *begin;
   }
   return ret;
}

L'inconvénient de fournir un exemple de code - je vois que d'autres ont déjà suggéré la même idée.

Notez que bien que la norme ait un min_element et un max_element, leur utilisation nécessiterait de parcourir les données deux fois, ce qui pourrait poser un problème si le tableau est grand. Des normes récentes ont résolu ce problème en ajoutant un std::minmax_element, qui fait la même chose que find_extremaci - dessus (trouvez à la fois les éléments minimum et maximum dans une collection en un seul passage).

Edit: Résoudre le problème de la recherche de la plus petite valeur non nulle dans un tableau de unsigned: observez que les valeurs non signées «s'enroulent» lorsqu'elles atteignent un extrême. Pour trouver la plus petite valeur non nulle, nous pouvons soustraire une de chacune pour la comparaison. Toute valeur nulle sera "enveloppée" à la plus grande valeur possible pour le type, mais la relation entre les autres valeurs sera conservée. Une fois que nous avons terminé, nous en rajoutons évidemment un à la valeur que nous avons trouvée.

unsigned int min_nonzero(std::vector<unsigned int> const &values) { 
    if (vector.size() == 0)
        return 0;
    unsigned int temp = values[0]-1;
    for (int i=1; i<values.size(); i++)
        if (values[i]-1 < temp)
            temp = values[i]-1;
    return temp+1;
}

Notez que cela utilise toujours le premier élément pour la valeur initiale, mais nous n'avons toujours pas besoin de code de «cas spécial» - puisque cela se terminera par la plus grande valeur possible, toute valeur non nulle sera comparée comme étant plus petite. Le résultat sera la plus petite valeur différente de zéro, ou 0 si et seulement si le vecteur ne contient aucune valeur différente de zéro.

Pour trouver manuellement le minimum d'un tableau, vous n'avez pas besoin de connaître la valeur minimum de float:

float myFloats[];
...
float minimum = myFloats[0];
for (int i = 0; i < myFloatsSize; ++i)
{
  if (myFloats[i] < minimum)
  {
    minimum = myFloats[i];
  }
}

Et un code similaire pour la valeur maximale.

Puis-je vous suggérer d'initialiser vos variables "max et min jusqu'ici" non pas à l'infini, mais au premier nombre du tableau?