C++ “À Virgule Flottante " Enum”

Je suis à la recherche d'une solution en utilisant le C++03 standard (je suis limité à l'utilisation de cette version de la norme pour plusieurs années encore). Solutions pour le C++11 sont également les bienvenus, mais ne sera pas "accepté" que la réponse à cette question.

Ce qui est une simple, concis que je peux représenter un ensemble de constantes de valeurs à virgule flottante comme un seul type (similaire à un enum) pour assurer la sécurité du type sans encourir des frais généraux et encore me permettre d'opérer sur les valeurs comme des flotteurs directement?

Le résultat final est que j'aimerais être capable de faire quelque chose comme ce qui suit:

enum FloatingPointEnum
{
   VALUE1 = 0.1234f,
   ...
   VALUEN = 0.6789f
};


float SomeFunction(FloatingPointEnum value)
{
    float new_value;
    /* perform some operation using "value" to calculate "new_value" */
    new_value = static_cast<float>(value); //<- a simplistic example
    return new_value;
}

Alors que je peux penser à plusieurs solutions, aucune n'est aussi propre/simple/simple que je le voudrais et je me dis que quelqu'un doit déjà avoir une solution élégante à ce problème (pourtant, je n'arrive pas à en trouver un dans ma recherche).

EDIT:

Je voudrais l'appel suivant à SomeFunction avec une valeur qui n'est pas spécifié directement une valeur dans le type énuméré à l'échec de compilation:

float nonEnumeratedValue = 5.0f
SomeFunction(nonEnumeratedValue);

de sécurité du type <-> "encore me permettre d'opérer sur les valeurs comme des flotteurs directement" Que voulez-vous dire? Si il y a une conversion implicite de ce type, pour float, il ne serait pas de type sécurisé. Si il n'y a rien, vous ne pouvez pas manipuler comme des floats directement. Pourriez-vous donner quelques exemples?
Des exemples de code que vous souhaitez ne parviennent pas à compiler en raison de la sécurité de type serait utile.

OriginalL'auteur statueuphemism | 2013-10-16

c++c++03 enumeration floating-point

7

quelqu'un doit déjà avoir une solution élégante à ce problème

Il ya beaucoup de problèmes qui n'ont pas de solution élégante (et beaucoup qui n'ont pas de solution à tous). Ce qui vous fait penser à ce problème? Cette hypothèse est très défectueux. Le plus proche que vous pouvez obtenir est d'utiliser une classe wrapper.
```
class FloatingPointEnum {
    float f;
    FloatingPointEnum(float arg) : f(arg) {}
public:
    static const FloatingPointEnum Value1;
    static const FloatingPointEnum Value2;
    operator float() const { return f; }
};
const FloatingPointEnum FloatingPointEnum::Value1(0.1234f);
const FloatingPointEnum FloatingPointEnum::Value2(0.6789f);
```
Je vous remercie pour votre relativement élégant réponse. En ce qui concerne votre commentaire sur "quelqu'un doit déjà avoir une solution élégante à ce problème: le Temps et encore une fois, la communauté de l'internet m'a montré un certain nombre de solutions élégantes à des problèmes. J'ai pensé qu'il valait mieux demander que de passer par le processus de réinventer la roue et de commencer par un carré.
C'est assez juste, et je ne vais pas dire que vous avez eu tort de demander, mais il n'est pas bon pour assumer une solution existe.

OriginalL'auteur Puppy
1

En C++11, vous pouvez utiliser constexpr à réaliser ce que vous voulez.

constexpr - spécifie que la valeur d'une variable ou d'une fonction peut apparaître dans des expressions constantes

http://en.cppreference.com/w/cpp/language/constexpr

Avec constexpr vous définir une constante de compilation. Cela ne fonctionne que pour littérale types, tels que float. Car, dans le même temps, nous voulons
```
float nonEnumeratedValue = 5.0f;
SomeFunction(nonEnumeratedValue);
```
à l'échec, on ne peut pas utiliser un simple typedef. Au lieu de cela, nous utilisons de Boost BOOST_STRONG_TYPEDEF.
```
#include <boost/serialization/strong_typedef.hpp>

BOOST_STRONG_TYPEDEF(float, FloatingPointEnum);
constexpr float VALUE1 = 0.1234f;
constexpr float VALUEN = 0.6789f;

float SomeFunction(FloatingPointEnum value)
{
  float new_value;
  /* perform some operation using "value" to calculate "new_value" */
  new_value = static_cast<float>(value); //<- a simplistic example
  return new_value;
}
```
Maintenant, vous pouvez appeler la fonction uniquement avec les instances de FloatingPointEnum. Malheureusement, l'instanciation de la syntaxe n'est pas si agréable plus
```
FloatingPointEnum f {VALUEN};
```
Alternativement, vous pouvez simplement utiliser la D langage de programmation, où virgule flottante les énumérations sont pris en charge et le code suivant fonctionne comme prévu:
```
enum FloatingPointEnum
{
   VALUE1 = 0.1234f,
   //...
   VALUEN = 0.6789f
};


float SomeFunction(FloatingPointEnum value)
{
    float new_value;
    new_value = value; //No cast needed, welcome to D!
    return new_value;
}
```
Appel SomeFunction avec un float résultats dans
```
Error: function test.SomeFunction (FloatingPointEnum value) is not callable using argument types (float)
```
OriginalL'auteur Henri Menke
1

Une autre solution possible, pas toujours applicables, mais très propre, est d'utiliser précision fixe.

Permet d'imaginer que vous avez-vous enum contenant une certaine distance en mètres
```
enum DistancesMeter{
 A = 0.25,
 b = 0.05,
};
```
alors vous pouvez tout simplement passer à l'utilisation mm
```
enum DistancesMM{
 A = 250,
 b = 50,
};
```
OriginalL'auteur mauro

Vous devez vous connecter pour publier un commentaire.