What is a good way to define CONSTANT?

[Morgan Cheng]

Hi,

In my program module, there are some Constants should be defined to be
integer key value of std::map. In the module, methods of a few classes
will return std::map containing value indexed by constant integer key value.
I am wondering what is a good way to define these constants.
1) #define A = 0
#define B = 1
#define C = 2

2) enum {
A, B, C
}

3) class AbcConstant {
enum {
A, B, C
}
};
Which one is best? I prefer option 3, because usage of constant should
be AbcConstant::A or AbcConstant::B, it is clear that the constants are
defined in class AbcConstant.

Any recommmendation ?

[Ivan Vecerina]

"Morgan Cheng" <mo************ @gmail.com> wrote in message
news:cp******** **@avnika.corp. mot.com...

In my program module, there are some Constants should be defined to be
integer key value of std::map. In the module, methods of a few classes
will return std::map containing value indexed by constant integer key
value. [ Unless you have a lot of possible map entries and most of them are
left unused most of the time, I would use a struct with
named fields rather than a map. ]
I am wondering what is a good way to define these constants.
1) #define A = 0
#define B = 1
#define C = 2 I assume you mean:
#define A 0
#define B 1
#define C 2
Definitely not a good idea, because you cannot control the scope
in which the constants are accessible (e.g. cannot be scoped
within a specific namespace or function scope).
2) enum {
A, B, C
} ; //missing
3) class AbcConstant { I assume you would insert the following here:
public: enum {
A, B, C
} ; // missing };
Which one is best? I prefer option 3, because usage of constant should be
AbcConstant::A or AbcConstant::B, it is clear that the constants are
defined in class AbcConstant.

Any recommmendation ?

Either 2 or 3, it depends. In some cases, the definition of the
constants is already within a specific enough namespace/scope,
so adding an explicit AbcConstant scoping is pointless.
On the other hand, if you are tempted to add a specific prefix
to the constant names, using an extra class or namespace scope
may be a better approach.

Cheers,
Ivan
--
http://ivan.vecerina.com/contact/?subject=NG_POST <- email contact form
Brainbench MVP for C++ <> http://www.brainbench.com

[EventHelix.com]

class AbcConstant {
public:
enum {
A, B, C
}
};

Option #3 seems to be the best. This would make your enums similar to
C#.

Option #2 however is the most commonly used one.

Also, if the type of the constant is important, you might want to
consider:
const int A=0; etc.

Deepa
--
http://www.EventHelix.com/EventStudio
EventStudio 2.5 - Generate sequence diagrams from plain text input

[Peter Koch Larsen]

"Morgan Cheng" <mo************ @gmail.com> skrev i en meddelelse
news:cp******** **@avnika.corp. mot.com...

Hi,

In my program module, there are some Constants should be defined to be
integer key value of std::map. In the module, methods of a few classes
will return std::map containing value indexed by constant integer key
value.
I am wondering what is a good way to define these constants.
1) #define A = 0
#define B = 1
#define C = 2

2) enum {
A, B, C
}

3) class AbcConstant {
enum {
A, B, C
}
};
Which one is best? I prefer option 3, because usage of constant should be
AbcConstant::A or AbcConstant::B, it is clear that the constants are
defined in class AbcConstant.

Any recommmendation ?

As EventHelix pointed out, you've mistakingly declared the enum private.
Better yet is to use a struct.
/Peter

[Paavo Helde]

Morgan Cheng <mo************ @gmail.com> wrote in
news:cp******** **@avnika.corp. mot.com:

Hi,

In my program module, there are some Constants should be defined to be
integer key value of std::map. In the module, methods of a few classes
will return std::map containing value indexed by constant integer key
value. I am wondering what is a good way to define these constants.
1) #define A = 0
#define B = 1
#define C = 2

2) enum {
A, B, C
}

3) class AbcConstant {
enum {
A, B, C
}
};

If the constants are not strictly related to one particular class, I
would prefer:

namespace AbcConstant {
enum {
A, B, C
}
}

Regards
Paavo

[Swampmonster]

3) class AbcConstant {
enum {
A, B, C
}
};

If the constants are not strictly related to one particular class, I
would prefer:

namespace AbcConstant {
enum {
A, B, C
}
}

And if that constants shall have type I'd go for constants in a
namespace or class - wherever they belong:

namespace Foo{
const size_t a = 100;
const char b = 10;
//...
}

class Bar {
public:
static const size_t c_a = 100;
static const char c_b = 10;
};

[Siemel Naran]

"Morgan Cheng" <mo************ @gmail.com> wrote in message

2) enum {
A, B, C
}

3) class AbcConstant {
enum {
A, B, C
}
};
Which one is best? I prefer option 3, because usage of constant should
be AbcConstant::A or AbcConstant::B, it is clear that the constants are
defined in class AbcConstant.

Options 3 forces client to prefix with AbcContact::, which could get to be a
nuisance. See the response by Paavo about namespaces, and clients can do
using namespace AbcConstant if they choose.

[Jonathan Mcdougall]

Morgan Cheng wrote:

Hi,

In my program module, there are some Constants should be defined to be
integer key value of std::map. In the module, methods of a few classes
will return std::map containing value indexed by constant integer key
value.
If these constants are part of a class, make them part of the class.

class C
{
public:
enum abc
{
a, b, c
};
};

That way, you get the type safety of the enum and the scope of the class.
I am wondering what is a good way to define these constants.
1) #define A = 0
#define B = 1
#define C = 2
Definitly not for obvious reasons.

int main()
{
int A = 2; // oups
}
2) enum {
A, B, C
}
Ok, but now the names are in the global namespace.
3) class AbcConstant {
enum {
A, B, C
}
};

Ok, but now you loose the type safety.
Jonathan