Quick Question Quick Answer

[JKop]

Take the following:
enum Sense
{
Vision,
Hearing,
Touch,
Smell
};
void Jaguar(const Sense& sense)
{
return;
}
int main(void)
{
Sense sense = Hearing;

Jaguar(sense);

Jaguar(Hearing) ;

int Hearing;

Jaguar(Sense::H earing); //ERROR `Sense' is not an aggregate type

return 0;
}

How do I tell it that I'm referring to "Hearing" from the enum "Sense", and
not the local variable entitled "Hearing"?!
-JKop

[Jorge Rivera]

> How do I tell it that I'm referring to "Hearing" from the enum
"Sense", and

not the local variable entitled "Hearing"?!

I think you just hit a fundamental limitation of enum types in C++.

enums are inherently integer values, and as you point out, there is no
real way to make this distinction.

One possible solution is to enclose your enum in a namespace.

Eg.

namespace Sense{
enum SenseType
{
Vision, Hearing, Touch, Smell
};
}

void Jaguar(const Sense::SenseTyp e& sense);

now you function can be called using

Jaguar(Sense::H earing);
JLR

[Marc]

JKop wrote:

Jaguar(Sense::H earing); //ERROR `Sense' is not an aggregate type

Try ::Hearing

[Stephen Waits]

JKop wrote:

How do I tell it that I'm referring to "Hearing" from the enum "Sense", and
not the local variable entitled "Hearing"?!

Don't do this for the same reason you don't do this:

int blah()
{
float a;
int a;

...
}

[JKop]

It's about time I got a real in-depth C++ book, or maybe read the standard a
little bit.

Anyway, here's what I've realized... By writing:
enum Water
{
chocolate,
monkey,
orange,
five,
};
you *are* in fact declaring global const variables and you *are* using up
token-names. For instance, the following will fail to compile:
enum Water
{
chocolate,
monkey,
orange,
five,
};

enum Oil
{
chocolate,
monkey,
orange,
five
};
Multiple definition.
Moving on, here's a nice bit of code:

namespace Water {
enum Water
{
chocolate,
monkey,
orange,
five,
}; }

namespace Oil {
enum Oil
{
chocolate,
monkey,
orange,
five
}; }


void WaterPP(const Water::Water& pp)
{
return;
}

void OilSS(const Oil::Oil& ss)
{
return;
}

int main(void)
{
Water::Water Watergg;

Oil::Oil Oilkk;
WaterPP(Watergg );

WaterPP(Water:: chocolate);

//WaterPP(chocola te); //ERROR undeclared
OilSS(Oilkk);

OilSS(Oil::choc olate);

//OilSS(chocolate ); //ERROR undeclared
int chocolate; //This own't interfer!

}

Namespaces, gotta love them.
-JKop

[Julie]

JKop wrote:

namespace Water {
enum Water
{
chocolate,
monkey,
orange,
five,
}; }
...
void WaterPP(const Water::Water& pp)
{
return;
}

You may want to consider a different name for the enum to differentiate it from
the namespace so that you don't have things like Water::Water, etc. Some other
naming choices include Type, Value, etc. With naming like that, you can then
use Water::Type& pp which may be a little easier to follow/read.

[Stephen Waits]

JKop wrote:

Anyway, here's what I've realized... By writing:

enum Water
{
chocolate,
monkey,
orange,
five,
};

you *are* in fact declaring global const variables and you *are* using up
token-names. For instance, the following will fail to compile:

Nope.

--Steve

[JKop]

Stephen Waits posted:

JKop wrote:

Anyway, here's what I've realized... By writing:

enum Water
{
chocolate,
monkey,
orange,
five,
};

you *are* in fact declaring global const variables and you *are* using
up token-names. For instance, the following will fail to compile:

Nope.

--Steve

Now that's just stupid. Express yourself, elborate.
-JKop

[Julie]

Stephen Waits wrote:

JKop wrote:

Anyway, here's what I've realized... By writing:

enum Water
{
chocolate,
monkey,
orange,
five,
};

you *are* in fact declaring global const variables and you *are* using up
token-names. For instance, the following will fail to compile:

Nope.

--Steve

You are right -- "Nope." doesn't compile for me either.

[Stephen Waits]

They aren't variables. See 3.9.2-1 and 7.2.

--Steve