Assigning int x = 'abc' ;

Question

I was doing a code review and I saw assignment of single quoted strings to enum values:

enum
{
  Option_1 = 'a',
  Option_2 = 'b'
} ;

While this makes for slightly more readable code (though the enum's meaning should be pretty much in the name of the num), it looks silly to me.

I didn't know you COULD do that and after studying it, I can see that all that happens is the binary value of the "characters" you're using gets thrown into an int.

Does anyone else do this in practice? Or is this a bad practice?

Answer 1

It is definitely perfectly legal according to ISO C and C++ standards. And it is a fairly reasonable practice if those enum values are serialized to text (e.g. CSV) files as those characters. Otherwise, I don't see much point. I guess it could give some debugging benefits, but all good C/C++ debuggers I know can resolve enum values to corresponding symbols anyway.

Answer 2

Unless code somewhere expects Option_1 to be 'a', I don't see the benefit.

Answer 3

chars are just 1 byte ints, so why not?

Answer 4

Sometimes enums with explicit values are used where the actual value is important. If those values are "ascii value of the letter a" why shouldn't you tell the reader by assigning 'a'?

Answer 5

It looks ok to me, would you rather have:

enum
{
  Option_1 = 97,
  Option_2 = 98
} ;

Answer 6

You can even assign multibyte "values" that end up being up to 32-bit ints:

enum t_f_fnf
{
    true = 'true',
    false = 'fals',
    file_not_found = 'fnf!'
};

(With a nod to the dailywtf. :) )

Answer 7

That is not a single-quoted string — it's a character literal. Using a character literal in an enum is essentially the same as assigning a char to an int — it's totally legal and can be quite useful in many situations.

Answer 8

Hiya, please consider this simple example I've made for you, as you can see it is legal to use enums this way. In my case, I use them as a sort of internal constants for a class. Enjoy.

#include <iostream>

using namespace std;

class VegetableBasket
{
    enum { Max_Potatoes = 2 }; // This is a legal usage...
    enum { Max_Tomatoes = 3 };  // In here the enums serve as class's internal constants
    public :
     // Constructors
     VegetableBasket() : tomatoes(0), potatoes(0) {}
     VegetableBasket(int t, int p) : tomatoes(t), potatoes(p) 
     { 
      if(tomatoes > Max_Tomatoes) 
       tomatoes = Max_Tomatoes;
      if(potatoes > Max_Potatoes)
       potatoes = Max_Potatoes;
     }
     // Accessors
     int getMaxPotatoes() const { return Max_Potatoes; }
     int getMaxTomatoes() const { return Max_Tomatoes; }
     int getPotatoes() const { return potatoes; }
     int getTomatoes() const { return tomatoes; }
    private :
     int tomatoes;
     int potatoes;
};


void main()
{
    VegetableBasket basket1(1, 1);
    VegetableBasket basket2(5, 6);

    cout << "The basket holds : " << basket1.getMaxPotatoes() 
      << " max potatoes, and " << basket1.getMaxTomatoes()
      << " max tomatoes" << endl;

    cout << "Basket 1 holds : " << basket1.getPotatoes()
      << " potatoes and "    << basket1.getTomatoes()
      << " tomatoes" << endl;

    cout << "Basket 2 holds : " << basket2.getPotatoes()
      << " potatoes and "    << basket2.getTomatoes()
      << " tomatoes" << endl;
}