Re: Negative float problem

["Hyman Rosen" <hyman.rosen@gmail.com>]

Martin Dowie wrote:
> Yup, you can't have overloaded enumeration values
> I guess because they are really just 'int', so which
> one would you mean?

No, that's not why. Enumerators have the type of their
enumeration. But enumerators go into their enclosing
namespace or class, so having multiple ones causes name
conflicts. You can actually simulate Ada's approach in
C++ by hand, as I show below. You can probably reduce
the boilerplate even more by using the Boost preprocessor
library, and that would also let you automatically get
string versions of the enumerators like Ada has.

#include <iostream>
#include <ostream>

struct Color { enum E { Red, Blue }; typedef E (&e)(E); };
struct Traffic_Light { enum E { Green, Amber, Red }; typedef E (&e)(E);
};

#define EDEF(C,e) C::E e(C::E = C::e) { return C::e; }
EDEF(Color, Red)
EDEF(Color, Blue)
EDEF(Traffic_Light, Green)
EDEF(Traffic_Light, Amber)
EDEF(Traffic_Light, Red)

void f_c(Color::e v)
 { std::cout << "Color: " << v(Color::E()) << "\n"; }
void f_t(Traffic_Light::e v)
 { std::cout << "Traffic_Light: " << v(Traffic_Light::E()) << "\n"; }

// Notice there are two Reds defined at global scope with no conflict
// and that each function is called with the proper Red.
int main() { f_c(Red); f_t(Red); }