Re: Problem with initialization of array of class objects
On Feb 21, 4:30 pm, "Alf P. Steinbach" <al...@start.no> wrote:
On Feb 21, 8:49 am, "Alf P. Steinbach" <al...@start.no> wrote:
In general it's a good idea to reserve all uppercase names
for macros. Using them for constants is a Java'ism. Leads
to problems in C++.
Isn't it more of a C'ism? As in #define MAX ...?
The Java convention (probably) stems from the C convention to
use all uppercase for macros. In early C one had to use
macros for constants, so constants also typically had all
uppercase names. But it's been some years since 1972, and C++
gives the ability to define constants without using macros.
It was the convention in early C++ as well. We've learned
A small historical note: in early C, I'm not sure that the
conventions were that fixed. There was a convention that macros
which could be used as a function obeyed the same naming
conventions as a function. There was also a convention that
manifest constants were all caps---and manifest constants were
(and still are) implemented by means of a macro in C. Beyond
that, it was pretty open---putc was almost always a macro, for
example, and arguable was distinct from a function, because it
evaluated its FILE* argument twice. (Exactly how close to a
function "used as a function" implied was generally not stated.)
When I started using C++ professionally, the convention was
still generally all caps for constants. But the first questions
were being raised; Jon Bentley (I think) had a quote along the
lines of "one man's constant is another man's variable", and
real applications were encountering the case where evolution
caused a "constant" to be read from a configuration file. I
remember being among the first in my company to argue against
all caps for constants.
Of course, that was all a very long time ago (for this
profession, anyway). I'd say that the all cap's for macros has
been pretty well established for at least ten years now, maybe
more. And we have a case of Java enshrining something that was
already beginning to be recognized as a mistake in C++.
Since macros don't respect scopes it's generally not a good
idea to let non-macro names enter that "namespace" in C++
(note: Java doesn't have this problem, because Java doesn't
have a preprocessor).
But even in Java, one man's constants are another man's
variables. And the Java library itself doesn't adhere strictly
to the rule (probably because some constants later became
variables, and vice versa---although it's hard to imagine that
Color::red was ever anything but a constant).
James Kanze (GABI Software) email:firstname.lastname@example.org
Conseils en informatique orient=E9e objet/
Beratung in objektorientierter Datenverarbeitung
9 place S=E9mard, 78210 St.-Cyr-l'=C9cole, France, +33 (0)1 30 23 00 34