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"?

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

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

Thanks, glad to have it all in one place.