Enum and circular definition

[Paul E Collins]

enum X { A, B = A } // will compile
enum Y { B = A, A } // won't, claims "circular reference"

That's a bit strange, isn't it?

Eq.

[Chris Jobson]

enum X { A, B = A } // will compile

enum Y { B = A, A } // won't, claims "circular reference"

That's a bit strange, isn't it?

If you don't specify a value for an enum it uses 1 more than the previous
value (or 0 for the first value), so in your first example A is given the
value 0 (because it's the first value) and then B is given the same value
(because you've specified it's equal to A).

In the second case you're saying B should be equal to A, so it needs to work
out the value of A. But since A has no assigned value and follows B, the
value of A should be B+1. Hence B is defined in terms of A and A is defined
in terms of B - a circular reference.

Chris Jobson

[=?Utf-8?B?U3VqZWV0?=]

I think the error is that the evalution of the value for B involves a
circular reference. This is because, in case of enum Y { B = A, A } the
evaluation of A depends on what the value of B will be. But then if B = A how
will you evaluate B

However in case enum X { A, B = A } , A can be evaluated independenly and
so can be B after that.
I guess thats the reason.

Sujeet

"Paul E Collins" wrote:

enum X { A, B = A } // will compile
enum Y { B = A, A } // won't, claims "circular reference"

That's a bit strange, isn't it?

Eq.

[Rudy Velthuis]

Paul E Collins wrote:

enum X { A, B = A } // will compile
enum Y { B = A, A } // won't, claims "circular reference"

That's a bit strange, isn't it?

I don't think so.

And why use a forward defined value anyway? Note that { B, A = B }
would be a valid equivalent for it.

--
Rudy Velthuis http://rvelthuis.de

"Raymond's Law of Software: Given a sufficiently large number of
eyeballs, all bugs are shallow." -- Eric S. Raymond

[Paul E Collins]

"Chris Jobson" <ch**********@btinternet.comwrote:

In the second case you're saying B should be equal to A, so it needs to
work out the value of A.

Oh yeah, of course. Good point. I bizarrely almost forgot that they have
numeric values, because I never define or use those unless it's a bitmask.

Eq.

[Duggi]

On Jun 12, 11:57*pm, "Paul E Collins" <[e-mail]>
wrote:

enum X { A, B = A } // will compile
enum Y { B = A, A } // won't, claims "circular reference"

That's a bit strange, isn't it?

Eq.

I think Chris Jobson explained the reason why it is so.

Is that just a knowledge sharing question or are you trying to solve
some issue?

I am trying to see some usecase for that code. As long as I know
nowadays C# programmers does not need to think enums in terms of
numbers or attached values inside. They are become more abstract.
Those were the good old days of C++, we try comparing the value of
enum with int values in if statements.

-Cnu