Use of macros in C++?

[Alex Buell]

A previous thread about macros just reminded me to ask this. I have
avoided using macros and defined some constants i.e.:

const int BYTES_PER_TRACK = 10 * 256;
const int TRACK0_SS_OFFSE T = 0;
const int TRACK0_SS_OFFSE T = 10 * 256;

Now, the problem is that I have several modules in my project that
references these constants, so I have to use 'extern const in
BYTES_PER_TRACK ' etc., in the main header file so the constants are
available to other modules.

I feel that in a situation like that wouldn't it be better to use
macros intead? Or not?

Thanks for any insights offered.
--
http://www.munted.org.uk

Take a nap, it saves lives.

[Alf P. Steinbach]

* Alex Buell:

A previous thread about macros just reminded me to ask this. I have
avoided using macros and defined some constants i.e.:

const int BYTES_PER_TRACK = 10 * 256;
const int TRACK0_SS_OFFSE T = 0;
const int TRACK0_SS_OFFSE T = 10 * 256;
Use of all uppercase for names is likely to conflict with macros; it's a
bad idea (see this group's FAQ, and also Bjarne Stroustrup's FAQ).

It's a Java convention, where it isn't a problem because Java doesn't
have a preprocessor.

Java got it from early C (which didn't have 'const', so that the
preprocessor had to be used for constants, where that convention helped
to avoid conflict with ordinary non-preprocessor symbols).

Essentially you've taken something very bad from the mists of historical
time, and reintroduced it in a descendant language of the language where
it originated -- a descendant language that helped to expel the monster.

Don't copy conventions and other things blindly.

Now, the problem is that I have several modules in my project that
references these constants, so I have to use 'extern const in
BYTES_PER_TRACK ' etc., in the main header file
Well, other don't have to do that.

so the constants are
available to other modules.
They should be defined or at least declared in a header file, yes.

I feel that in a situation like that wouldn't it be better to use
macros intead? Or not?

Thanks for any insights offered.

Follow the net directions indicated above.
--
A: Because it messes up the order in which people normally read text.
Q: Why is it such a bad thing?
A: Top-posting.
Q: What is the most annoying thing on usenet and in e-mail?

[Roland Pibinger]

On Sun, 7 May 2006 10:35:45 +0100, Alex Buell
<al********@mun ted.org.uk> wrote:

A previous thread about macros just reminded me to ask this. I have
avoided using macros and defined some constants i.e.:

const int BYTES_PER_TRACK = 10 * 256;
const int TRACK0_SS_OFFSE T = 0;
const int TRACK0_SS_OFFSE T = 10 * 256;

Now, the problem is that I have several modules in my project that
references these constants, so I have to use 'extern const in
BYTES_PER_TRAC K' etc., in the main header file so the constants are
available to other modules.

I feel that in a situation like that wouldn't it be better to use
macros intead? Or not?

Consider using enums:

enum {
BYTES_PER_TRACK = 10 * 256;
TRACK0_SS_OFFSE T = 0;
// ...
};

Best wishes,
Roland Pibinger

[Alex Buell]

On Sun, 7 May 2006 10:35:45 +0100 Alex Buell <al********@mun ted.org.uk>
waved a wand and this message magically appeared:

const int TRACK0_SS_OFFSE T = 0;
const int TRACK0_SS_OFFSE T = 10 * 256;

Err, the second one should be:

const int TRACK0_DS_OFFSE T = 10 * 256;

--
http://www.munted.org.uk

Take a nap, it saves lives.

[John Carson]

"Alex Buell" <al********@mun ted.org.uk> wrote in message
news:2006050710 3545.8dea4b40.a l********@munte d.org.uk

A previous thread about macros just reminded me to ask this. I have
avoided using macros and defined some constants i.e.:

const int BYTES_PER_TRACK = 10 * 256;
const int TRACK0_SS_OFFSE T = 0;
const int TRACK0_SS_OFFSE T = 10 * 256;

Now, the problem is that I have several modules in my project that
references these constants, so I have to use 'extern const in
BYTES_PER_TRACK ' etc., in the main header file so the constants are
available to other modules.

I feel that in a situation like that wouldn't it be better to use
macros intead? Or not?

Macros are only visible within the translation unit in which they are
#defined, which is the same as const ints (without the extern modifier). So
what advantage do macros offer?

--
John Carson

[Alex Buell]

On Sun, 07 May 2006 09:58:58 GMT rp*****@yahoo.c om (Roland Pibinger)
waved a wand and this message magically appeared:

I feel that in a situation like that wouldn't it be better to use
macros intead? Or not?

Consider using enums:

enum {
BYTES_PER_TRACK = 10 * 256;
TRACK0_SS_OFFSE T = 0;
// ...
};

That along with putting it into its own name space might be a better
idea. Thanks.

--
http://www.munted.org.uk

Take a nap, it saves lives.

[Rolf Magnus]

Alex Buell wrote:

A previous thread about macros just reminded me to ask this. I have
avoided using macros and defined some constants i.e.:

const int BYTES_PER_TRACK = 10 * 256;
const int TRACK0_SS_OFFSE T = 0;
const int TRACK0_SS_OFFSE T = 10 * 256;

Now, the problem is that I have several modules in my project that
references these constants, so I have to use 'extern const in
BYTES_PER_TRACK ' etc., in the main header file so the constants are
available to other modules.

I feel that in a situation like that wouldn't it be better to use
macros intead? Or not?

Not. Just define the constant in the header and don't make it extern.

[Alex Buell]

On Sun, 07 May 2006 12:47:53 +0200 Rolf Magnus <ra******@t-online.de>
waved a wand and this message magically appeared:

I feel that in a situation like that wouldn't it be better to use
macros intead? Or not?

Not. Just define the constant in the header and don't make it extern.

My preferred solution is:
namespace DISK
{
enum
{
BYTES_PER_TRACK = 10 * 256,

TRACK0_SS_OFFSE T = 0,
TRACK0_DS_OFFSE T = 10 * 256
};
};

And refer to them as:

if (ds)
offset = DISK::TRACK0_DS _OFFSET;

It's much nicer.
--
http://www.munted.org.uk

Take a nap, it saves lives.

[Rolf Magnus]

Alex Buell wrote:

On Sun, 07 May 2006 12:47:53 +0200 Rolf Magnus <ra******@t-online.de>
waved a wand and this message magically appeared:

> I feel that in a situation like that wouldn't it be better to use
> macros intead? Or not?

Not. Just define the constant in the header and don't make it extern.

My preferred solution is:
namespace DISK
{
enum
{
BYTES_PER_TRACK = 10 * 256,

TRACK0_SS_OFFSE T = 0,
TRACK0_DS_OFFSE T = 10 * 256
};
};

And refer to them as:

if (ds)
offset = DISK::TRACK0_DS _OFFSET;

It's much nicer.

Not really, IMHO. enum is for enumerated types, not for constants.

[Roland Pibinger]

On Sun, 07 May 2006 13:43:02 +0200, Rolf Magnus <ra******@t-online.de>
wrote:

Alex Buell wrote:

My preferred solution is:
namespace DISK
{
enum
{
BYTES_PER_TRACK = 10 * 256,

TRACK0_SS_OFFSE T = 0,
TRACK0_DS_OFFSE T = 10 * 256
};
};

And refer to them as:

if (ds)
offset = DISK::TRACK0_DS _OFFSET;

It's much nicer.

Not really, IMHO. enum is for enumerated types, not for constants.

Note that an anonymous ("typeless") enum is used. :-)