STL fonction permet de tester si une valeur est dans une certaine gamme?

J'ai une fonction: bool inBounds(int value, int low, int high). Est-il un STL équivalent, ce qui ne fait que des choses utiles (prend des variables de différents types, en particulier)? Je ne peux pas en trouver un à l'aide de Google, et je préfère la réutilisation plutôt que de ré-écrire.

Pourrais-je vous suggérer within comme un nom plus simple?

OriginalL'auteur simont | 2012-02-13

c++stl

11

En C++14, il n'y a pas d'équivalent direct d'une fonction comme celle-ci, mais pour les plus petits avec des types de rapide de l'égalité des comparaisons que vous pourriez utiliser std::pince:
```
if (val == std::clamp(val, low, high)) {
    ...
}
```
Alternativement, vous pouvez simplement écrire votre propre fonction pour tester ceci:
```
template <typename T>
    bool IsInBounds(const T& value, const T& low, const T& high) {
    return !(value < low) && (value < high);
}
```
Ce vérifie si value est dans l'intervalle [low, high). Si vous voulez l'intervalle [low, high], vous devez écrire ce que
```
template <typename T>
    bool IsInBounds(const T& value, const T& low, const T& high) {
    return !(value < low) && !(high < value);
}
```
Notez comment cela est défini uniquement en termes de operator <, ce qui signifie que toute la classe qui prend en charge operator < peut être utilisé ici.

De même, en voici une, en utilisant des comparateurs:
```
template <typename T, typename R, typename Comparator>
    bool IsInBounds(const T& value, const R& low, const R& high, Comparator comp) {
    return !comp(value, low) && comp(value, high);
}
```
Ce dernier a l'avantage agréable que low et high n'avez pas à être le même type que value, et aussi longtemps que le comparateur peut gérer que cela fonctionnera tout aussi bien.

Espérons que cette aide!

Merci. Je suis toujours provisoire avec des modèles - les exemples sont muchly apprécié.
Est la plus faible / exclusif à la limite supérieure intentionnelle?
J'ai supposé que c'est ce qui était prévu. Je vais poster une mise à jour si différentes limites sont souhaitées.
Inclusive inférieur, exclusif upper est ce que j'utilise en ce moment.

OriginalL'auteur templatetypedef
5
```
bool inBounds(int value, int low, int high)
```
a le léger inconvénient que vous devez vous rappeler quel est le paramètre qui va où.

Je ne peux pas être le seul dont parfaitement rationnel, paramètre de commande est ahurissante lors du retour de code après un certain temps.

Vous pourriez aller le mile supplémentaire et de définir
```
template<typename T>
class Interval
{
public:
    Interval(T lo, T hi) : low(lo), high(hi) {}
    bool contains(T value) const { return low <= value && value < high; }
private:
    T low;
    T high;
};
template<typename T>
Interval<T> interval(T lo, T hi) { return Interval<T>(lo, hi); }
```
Alors vous pouvez être plus explicite sur ce que tu veux dire:
```
if (interval(a, b).contains(value))
    //...
```
Si l'on est dans l'abstraction mode il n'est pas trop difficile à généraliser à accueillir différents inclusif/exclusif combinaisons.

Bien sûr, cela peut-être exagéré pour vos besoins.

YMMV, et tout ça.

OriginalL'auteur molbdnilo
1

Vous pourriez composer l'un de std::less, std::more, std::bind et std::compose, mais c'est vraiment exagéré.

Lambda sont beaucoup plus faciles:

[](int value, int low, int high){return !(value < low) && (value < high);}

ou, si elle est basse et haute sont à portée

[low, high](int value){return !(value < low) && (value < high)};

OriginalL'auteur MSalters
-1

Je l'avais presque pense que vous feriez mieux de ne pas tenter une telle apparence simple tâche avec une fonction entière et juste inline le comportement.

Quelque chose comme ceci:
```
  1 #include <iostream>
  2 
  3 int main() {
  4     int value = 5;
  5     bool inside = false;
  6     int lower = 0;
  7     int upper = 10;
  8     inside = lower < value && value < upper;
  9     printf("inside: %d", inside);
 10     return 0;
 11 }
```
Si vous avez une raison pour ne pas écrire le code comme ceci, s'il vous plaît laissez-moi savoir et je peux fournir un plus sophistiqué de réponse.

Vous avez besoin de fixer la ligne 8: lower < value < upper ne fonctionne pas correctement en C++. Vous auriez à le diviser en lower < value && upper < value. Je suis également en désaccord, ce qui devrait être insérée. C'est un bien propre sous-routine, et avec les compilateurs de la façon dont ils sont maintenant, il va presque certainement être insérée.
Ce n'est pas une question de performance dans mon cas, j'ai juste un moment difficile de justifier l'abstraction de cette distance avec les informations actuellement disponibles.
Je suis actuellement à l'aide de limites-case 4 valeurs, qui sort à une assez grande if déclaration - c'est beaucoup plus facile à lire si j'enveloppe le test dans une fonction, et il y a moins de chance de me typographiquement défaut.
Me semble raisonnable, l'autre réponse au sujet du TSL devraient bien vous servir ensuite. Si ce n'est pas de décrire ce que vous avez besoin.

OriginalL'auteur bitemyapp

Vous devez vous connecter pour publier un commentaire.