Thread: Forcing an enum to int?

Code:

class Object {
public:

 enum STYLE { SOLID = 0, NUL, HATCHED, PATTERN };
 enum HATCH { HORIZONTAL = 0, VERTICAL, FDIAGONAL, BDIAGONAL, CROSS, DIAGCROSS };

bool MakeHatched( HATCH style ) {
  //...
 }
};


int main() {
  Object b;

   //...OK...
  b.MakeHatched( Object::VERTICAL ); 
  
   //...nope, compiler rejects, needs a HATCH, cool...
  b.MakeHatched(Object::SOLID); 
 

 //... no matching call to MakeHatched(int);  
 //...canidates are MakeHatched(HATCH);  
  b.MakeHatched( 1 ); //...damn. I want to be able to use an int!
   
 }

So is there any way to force it to accept both? Because when I make a wrapper for the int, it accepts this:

Code:

   //...This compiles! No good!! Must be a HATCH!
  b.MakeHatched(Object::SOLID);

I was afraid of that! Ok, so no workarounds, huh? Thought maybe there was an undocumented feature of the enum I could exploit

You son of a ***, it almost worked too! Hacker!

Unfortunately, it still allows:

b.MakeHatched(10000);

Nice try though! Kudos....

Yeah, that's basically what I ended up doing (with assert). It's just too bad because that would be a perfect usage of an enum, to validate ranges of explicit variables at compile time...

No, but in this case, it would be...

/*edit*/

Windows defines several hundred numerical macros, which is the target of this experiment...

Well, let's say you were coding a windows program and were creating a certain brush. Now if you were certain that WHITE_BRUSH was a valid constant, then I would want you to be able to do:

brush.MakeStock(WHITE_BRUSH);

However, let's say you forgot the name of the constant and compiled this:

brush.MakeStock();

The compiler simply tells you it's an int. But using an enum, you would get:

canidates are: MakeStock(Brush::STOCK)

So you try:

brush.MakeStock(Brush::CROSS);

And you'd get:

no matching call to MakeStock(Brush::HATCH), canidates Brush::STOCK, etc.

But of course, typing:

brush.MakeStock(Brush::WHITE);

would compile fine and you'd know you were on track

Silly, I know, but nonetheless a feature I'd love to see.

So basically, since the enums and Windows constants have identical values, I wanted to give the user the option to use either...

...precisely...

There's a solution, instead of an enum, create a class.

Code:

class Object {
public:

  class STYLE
  {
    public: 
     STYLE(int i_style)
     {
        if (i_style > 3) throw InvalidSTYLEException();
        style = i_style;
     }
    private:
      int style;
  };
  
  static STYLE SOLID,NUL,HATCHED,PATTERN;

 /*The same with HATCH*/


bool MakeHatched( HATCH style ) {
  //...
 }
};

STYLE Object::SOLID = 0;
STYLE Object::NUL = 1;
/*etc.*/

Btw, Sebastiani, will your library be platform-independent or only work in Windows?

Excellent solution there, Sang-Drax. I was thinking of using a static class but wasn't sure how to implement it...
...and no the library won't be platform independant (although I sure wish it was!). Er, or was that and offer? Heh...