www.digitalmars.com         C & C++   DMDScript  

digitalmars.D.learn - Constants?

reply Mike L. <mike.linford gmail.com> writes:
Could someone lay out for me the different ways of doing constants in D (d1,
particularly)? I've heard things about const, final, invariant, and "anonymous
enums"?
Feb 11 2009
parent reply Jarrett Billingsley <jarrett.billingsley gmail.com> writes:
On Wed, Feb 11, 2009 at 4:09 PM, Mike L. <mike.linford gmail.com> wrote:

 Could someone lay out for me the different ways of doing constants in D (d1,
particularly)? I've heard things about const, final, invariant, and "anonymous
enums"?


OK, D1 doesn't have constness in the way that C/C++ and D2 do.  D1
only has constants and enums.

A constant is created with 'const':

const int x = 5;
const message = "hello"; // uses type inference to infer char[5]

'const' actually has different behavior depending on where it's used.
It's always used to declare variables (you can't put it on params, for
instance), but if you use 'const' as a class member:

class A
{
    const int x;

    this(int x)
    {
        this.x = x; // OK
        // this.x++; // NOT ok
    }
}

it works like the Java "final", in which case there is a copy of it in
each instance of A, but it can only be assigned once and it must be
assigned in the constructor.

If you want to dynamically initialize a module-level const, you can do
so in a static this():

const int x;

static this()
{
    x = something();
}

Again, x can only be assigned to once, and it must be assigned in the
static this().

'final' does not work the way it does in Java.  'final' was used to
mean more or less the same thing as in Java when D2 was new, but that
usage has been dropped.

'const' (and the other qualifier 'invariant') mean different things in
D2; I won't get into that here unless you really want to know.

The other kind of constant that D1 has is enumerations.  Enumerations
can be named:

enum Foo { Bar = 3 }

So Foo.Bar is a constant with the value 3.  Or they can be anonymous:

enum { Baz = 5 }

Baz is a constant with the value 5.

Enumerations differ from consts in that they do not consume any space
in the final outputted object/library/executable, whereas consts do.
This has actually been significant in some cases: the Windows header
ports, for instance, used the "const int Blah = ..." form for many
many constants, bloating the outputted object files by several dozens
of kilobytes.  The "enum: int { Blah = ... }" form consumes no extra
space in the executable.

Also: in D2, "enum" can be used as a storage class, like "const" or
"invariant", in which case the idea of "not taking any space in the
output" is preserved:

invariant int x = 5; // constant, but in the object files
enum int y = 5; // not in the object files
Feb 11 2009
parent reply Zarathustra <adam.chrapkowski gmail.com> writes:
For more documentation:
d1:
  const:
    <http://www.digitalmars.com/d/1.0/attribute.html#const>

  final:
    <http://www.digitalmars.com/d/1.0/class.html#Final>

  invariant:
    <http://www.digitalmars.com/d/1.0/class.html#Invariant>

  enums:
    <http://www.digitalmars.com/d/1.0/enum.html>

d2:
  const and invariant
    <http://www.digitalmars.com/d/2.0/const3.html>

  final:
    <http://www.digitalmars.com/d/2.0/class.html>

  enums:
    <http://www.digitalmars.com/d/2.0/enum.html>

Jarrett Billingsley Wrote:


 On Wed, Feb 11, 2009 at 4:09 PM, Mike L. <mike.linford gmail.com> wrote:

 Could someone lay out for me the different ways of doing constants in D (d1,
particularly)? I've heard things about const, final, invariant, and "anonymous
enums"?


 
 OK, D1 doesn't have constness in the way that C/C++ and D2 do.  D1
 only has constants and enums.
 
 A constant is created with 'const':
 
 const int x = 5;
 const message = "hello"; // uses type inference to infer char[5]
 
 'const' actually has different behavior depending on where it's used.
 It's always used to declare variables (you can't put it on params, for
 instance), but if you use 'const' as a class member:
 
 class A
 {
     const int x;
 
     this(int x)
     {
         this.x = x; // OK
         // this.x++; // NOT ok
     }
 }
 
 it works like the Java "final", in which case there is a copy of it in
 each instance of A, but it can only be assigned once and it must be
 assigned in the constructor.
 
 If you want to dynamically initialize a module-level const, you can do
 so in a static this():
 
 const int x;
 
 static this()
 {
     x = something();
 }
 
 Again, x can only be assigned to once, and it must be assigned in the
 static this().
 
 'final' does not work the way it does in Java.  'final' was used to
 mean more or less the same thing as in Java when D2 was new, but that
 usage has been dropped.
 
 'const' (and the other qualifier 'invariant') mean different things in
 D2; I won't get into that here unless you really want to know.
 
 The other kind of constant that D1 has is enumerations.  Enumerations
 can be named:
 
 enum Foo { Bar = 3 }
 
 So Foo.Bar is a constant with the value 3.  Or they can be anonymous:
 
 enum { Baz = 5 }
 
 Baz is a constant with the value 5.
 
 Enumerations differ from consts in that they do not consume any space
 in the final outputted object/library/executable, whereas consts do.
 This has actually been significant in some cases: the Windows header
 ports, for instance, used the "const int Blah = ..." form for many
 many constants, bloating the outputted object files by several dozens
 of kilobytes.  The "enum: int { Blah = ... }" form consumes no extra
 space in the executable.
 
 Also: in D2, "enum" can be used as a storage class, like "const" or
 "invariant", in which case the idea of "not taking any space in the
 output" is preserved:
 
 invariant int x = 5; // constant, but in the object files
 enum int y = 5; // not in the object files
Feb 11 2009
parent Mike L. <mike.linford gmail.com> writes:
Thanks, glad to have it all in one place.
Feb 12 2009