🚀 go-pugleaf

In article <4jgpqa$t09@nntp.interaccess.com>,
   brianmcg@interaccess.com (Brian V. McGroarty) wrote:
>Is this legal?  Borland and Microsoft compilers will accept the following:
>
>class AnyClass
>{
>    const int constInt;
>}
>
>The Borland compiler complains about the uninitialized constant, whereas
>the Microsoft compiler does not.  If a constructor is present, both will
>complain that the constant isn't initialized in the constructor, however
>neither will allow you to assign a value in the constructor by simply
>specifying "constInt= some value".  I have also attempted to initialize in
>a global variable "int AnyClass::constInt",  to determine whether static
>somehow became implicit -- still no go.  If this is legal, how is the value
>initialized?
[Snip]

That's perfectly legal.

However, you can't initialize the const member in the class
declaration, since you haven't instantiated an object of the class in
question which could receive the value. Furthermore, it would prevent
you from assigning different values to constInt in different instances
of the class, which in most cases is not what you want, either.

If you *really* want compile-time initialized constants, and can live
with something that has essentially the same properties as an integer,
use class-scope enums. If you need several compile-time constants with
the same value, you can use multiple untagged enums:

class AnyClass
{
    enum {FOO = 1, BAR = 1}; // multiple enums with same value; doesn't work!
    enum {FOO = 1};          // OK
    enum {BAR = 1};          // OK
}

To continue with the const class member for a moment, you can't
initialize the const class member in your constructor, as you already
noted -- this must be done using the initialization list. You can do
this as follows:

AnyClass::AnyClass() : constInt(0)
    {
    // other initialization code goes here
    }

or

AnyClass::AnyClass(int ConstValue) : constInt(ConstValue)
    {
    // other initialization code goes here
    }

The initialization is actually performed before your constructor is
entered; if more than one member is being initialized, it happens in
the order in which the members are declared in the class, *not* the
order in which they are listed in the initialization list.

I hope this helps!


Torsten Hoff
thoff@symantec.com

(The views and opinions expressed are my own, and
should not be construed as representing those of
Symantec Corporation)
---
[ comp.std.c++ is moderated.  To submit articles: try just posting with      ]
[ your news-reader.  If that fails, use mailto:std-c++@ncar.ucar.edu         ]
[ FAQ:      http://reality.sgi.com/employees/austern_mti/std-c++/faq.html    ]
[ Policy:   http://reality.sgi.com/employees/austern_mti/std-c++/policy.html ]
[ Comments? mailto:std-c++-request@ncar.ucar.edu                             ]