const int FOO vs #define FOO

[C. J. Clegg]

When you say "const int FOO = 0" (as the commonly-recommended C++
alternative to "#define FOO 0"), isn't that declaration globally
visible?

I have "const int FOO = 0;" in one source file and "extern int FOO;"
in another source file (also tried "extern const int FOO;") and at
link time, I get undefined references to FOO.

Removed the "const" from the FOO declaration and everything worked
fine.

Does "const" make it static (file scope)? Certainly seems to...

[Michiel.Salters]

C. J. Clegg wrote:

When you say "const int FOO = 0" (as the commonly-recommended C++
alternative to "#define FOO 0"), isn't that declaration globally
visible?
No. It's visible in the definition scope. I.e. if you define it in the
true-branch of
an if-statement, it's invisible in the else-branch. A #define will be
visible until
the #undef, or EOF.
I have "const int FOO = 0;" in one source file and "extern int FOO;"
in another source file (also tried "extern const int FOO;") and at
link time, I get undefined references to FOO.
Same scope? Besides, you must give them the same type.
Removed the "const" from the FOO declaration and everything worked
fine.

Does "const" make it static (file scope)? Certainly seems to...

IIRC, yes, unless defined extern. But since I only use extern in the
corresponding
header, this is never a problem. Using extern in an unrelated .h or
..cpp is a hack,
IMO.

HTH,
Michiel Salters

[C. J. Clegg]

On 20 Feb 2006 07:57:22 -0800, Mi*************@tomtom.com wrote:

C. J. Clegg wrote:

When you say "const int FOO = 0" (as the commonly-recommended C++
alternative to "#define FOO 0"), isn't that declaration globally
visible?

No. It's visible in the definition scope. I.e. if you define it in the
true-branch of
an if-statement, it's invisible in the else-branch. A #define will be
visible until
the #undef, or EOF.

I define it in global space, i.e. outside of any function or class.

In fact, for test, I have a file foo.cpp that has the single line

const int FOO = 0;

.... then I say "extern const int FOO;" at the top of other files, but
the other files can't see it.

So the question is, does it then become visible only to the file,
similar to "static int FOO"?

[Rolf Magnus]

C. J. Clegg wrote:

On 20 Feb 2006 07:57:22 -0800, Mi*************@tomtom.com wrote:

C. J. Clegg wrote:

When you say "const int FOO = 0" (as the commonly-recommended C++
alternative to "#define FOO 0"), isn't that declaration globally
visible?
No. It's visible in the definition scope. I.e. if you define it in the
true-branch of
an if-statement, it's invisible in the else-branch. A #define will be
visible until
the #undef, or EOF.

I define it in global space, i.e. outside of any function or class.

In fact, for test, I have a file foo.cpp that has the single line

const int FOO = 0;

... then I say "extern const int FOO;" at the top of other files, but
the other files can't see it.

Instead, put that in a header file "foo.h" and #include that header in all
of those files as well as foo.cpp.
So the question is, does it then become visible only to the file,
similar to "static int FOO"?

AFAIK, constants on namespace scope have internal linkage by default.

[ALiX]

C. J. Clegg wrote:

When you say "const int FOO = 0" (as the commonly-recommended C++
alternative to "#define FOO 0"), isn't that declaration globally
visible?

I have "const int FOO = 0;" in one source file and "extern int FOO;"
in another source file (also tried "extern const int FOO;") and at
link time, I get undefined references to FOO.

Removed the "const" from the FOO declaration and everything worked
fine.

Does "const" make it static (file scope)? Certainly seems to...

Yes it does. You can declare FOO as having external linkage by
prefixing the definition with 'extern', like this:

extern const int FOO = 0;

/ALiX

[C. J. Clegg]

On Mon, 20 Feb 2006 18:56:16 +0100, Rolf Magnus <ra******@t-online.de>
wrote:

C. J. Clegg wrote:

In fact, for test, I have a file foo.cpp that has the single line

const int FOO = 0;

... then I say "extern const int FOO;" at the top of other files, but
the other files can't see it.

Instead, put that in a header file "foo.h" and #include that header in all
of those files as well as foo.cpp.

Good evening, Rolf.

Ah, but "const int FOO = 0" allocates memory, specifically a block of
size int, and you're not supposed to put stuff in .h files that
allocate memory.

Anyway, if I say "const int FOO = 0" in a .h file and then #include
that .h file in two other files, don't I end up with two FOOs, and in
fact won't I get yelled at by the linker for duplicate symbols?

[C. J. Clegg]

On 20 Feb 2006 11:03:05 -0800, "ALiX" <al********@hotmail.com> wrote:

C. J. Clegg wrote:

Does "const" make it static (file scope)? Certainly seems to...

Yes it does. You can declare FOO as having external linkage by
prefixing the definition with 'extern', like this:

extern const int FOO = 0;

Thanks, I will try that.

[Ron House]

C. J. Clegg wrote:

Ah, but "const int FOO = 0" allocates memory, specifically a block of
size int, and you're not supposed to put stuff in .h files that
allocate memory.

Anyway, if I say "const int FOO = 0" in a .h file and then #include
that .h file in two other files, don't I end up with two FOOs, and in
fact won't I get yelled at by the linker for duplicate symbols?

You would in C, but not in C++. A const int in C is an int variable that
may not be changed. A const int in C++ is a compile-time name for the
constant number given in the definition, and allocates no storage.

--
Ron House ho***@usq.edu.au
http://www.sci.usq.edu.au/staff/house

[Jack Klein]

On Mon, 20 Feb 2006 10:27:26 -0500, C. J. Clegg
<re****************@nospam.no> wrote in comp.lang.c++:

When you say "const int FOO = 0" (as the commonly-recommended C++
alternative to "#define FOO 0"), isn't that declaration globally
visible?

I have "const int FOO = 0;" in one source file and "extern int FOO;"
in another source file (also tried "extern const int FOO;") and at
link time, I get undefined references to FOO.

Removed the "const" from the FOO declaration and everything worked
fine.

Does "const" make it static (file scope)? Certainly seems to...

You have just bumped into one of the "silent" changes from C in C++.
"const" on an object defined at file scope in C++ also gives the
object internal linkage, unlike in C.

The solution is to use:

extern const int FOO = 0;

....to restore the external linkage when you want it.

--
Jack Klein
Home: http://JK-Technology.Com
FAQs for
comp.lang.c http://c-faq.com/
comp.lang.c++ http://www.parashift.com/c++-faq-lite/
alt.comp.lang.learn.c-c++
http://www.contrib.andrew.cmu.edu/~a...FAQ-acllc.html

[Jack Klein]

On Tue, 21 Feb 2006 13:45:45 +1000, Ron House <ho***@usq.edu.au> wrote
in comp.lang.c++:

C. J. Clegg wrote:

Ah, but "const int FOO = 0" allocates memory, specifically a block of
size int, and you're not supposed to put stuff in .h files that
allocate memory.

Anyway, if I say "const int FOO = 0" in a .h file and then #include
that .h file in two other files, don't I end up with two FOOs, and in
fact won't I get yelled at by the linker for duplicate symbols?

You would in C, but not in C++. A const int in C is an int variable that
may not be changed. A const int in C++ is a compile-time name for the
constant number given in the definition, and allocates no storage.

....that is, unless its address is taken, of course.

Given:

extern int func1(const int &);
extern int func2(const int *);

const int FOO = 0;

int main()
{
return func1(FOO) + func2(&FOO);
}

....you can be fairly confident that FOO will be allocated storage,
especially if the called functions are in a separate translation unit.

--
Jack Klein
Home: http://JK-Technology.Com
FAQs for
comp.lang.c http://c-faq.com/
comp.lang.c++ http://www.parashift.com/c++-faq-lite/
alt.comp.lang.learn.c-c++
http://www.contrib.andrew.cmu.edu/~a...FAQ-acllc.html