assignment to enum - lvalue required in c/c++

Question

While tying my hands on enum I found that:

1. enum can't be assigned any literal (even of integral types).

   enum sign{alpha,beta};
   alpha=4;       //error: lvalue required as left operand of assignment
   

Regarding this I can't understand how enum is not a lvalue since it has a name (identifier).

2. In C++ Primer it has been given that:

An object of enumeration type may be initialized or assigned only by one of its enumerators or by another object of the same enumeration type.

It has also shown in an example that:

enum p1{var1A,var1B};
enum p2{var2A,var2B};

var2A=var1A //Error: var2A is not a p2 enumerator -> as written in the book
var2A=var2B //Correct as per the book

But why on assigning the correct value all I am getting is the same lvalue error which is being shown in point 1.

Answer 1

You can initialize your enumerators inside the enumerator-list, not outside of it:

enum sign { alpha = 4, beta };

alfa is not a "an object of enumeration type", it's an enumerator. If you had:

sign myenum;

then myenum would be "an object of enumeration type" and then you could do:

myenum = alpha;

or:

myenum = beta;

If you really want to go down that route, then use scoped enums (whose underlying type you can specify) and some std::underlying_type magic as a workaround:

enum class p1 { var1A, var1B };
enum class p2 : std::underlying_type<p1>::type { var2A = p1::var1A, var1B = var1A};

as you can't really have an enum as an underlying type of another enum.

More on the subject in this SO post:

Why can't I have an enum as the underlying type of another enum?

Answer 2

Just because something has a name, doesn't mean it's an lvalue. It's more complicated that than. For example, types have names and they're not values at all! You're probably thinking of expressions that use the name of a variable, which do tend to be lvalues. But an enumerator is not a variable.

Enumerators are not only constants, but they are also prvalues, so not only is the error message correct but it is also worded properly.

You can read about value categories on cppreference.com.

If your book said that var2A=var2B is valid, you would need a new book, because that is nonsense. But the quoted passage does not support your assertion. It's saying that you can create a fresh sign and initialise it from any of those enumerations, like sign mySign = var2A;.

Answer 3

When you do

enum sign{alpha,beta};

It's almost exactly equivalent to

#define alpha 0
#define beta 1

alpha and beta will be equivalent to 0 and 1 respectively, and just like C/C++ don't allow you to assign into 0 or 1, so will the enumerator constants be unassignable.

(In addition to the integer constants, enum sign{alpha,beta} also additionally creates an integer type called enum sign, whose values a debugger may print as alpha and beta instead of just 0 and 1, plus enumerator constants respect scoping and and #defines don't, but otherwise int #defines and enumerator constants are basically interchangable.)