I feel like I have a reasonable understanding of when to use
const as a parameter in a function or for const member functions.
However, I don't really understand why/when it should be used as
a type modifier.
For instance, the Programming in D book basically just says
(http://ddili.org/ders/d.en/const_and_immutable.html) that a
const variable is the same as an immutable variable, but you
should just use immutable.
The D spec uses slightly different terminology
(https://dlang.org/spec/const3.html), I think. I think the
storage class stuff is similar to what the PiD book says about
const parameters, while const types further below matches up with
what the book says about const variables.
So the line from the spec is
"Const types are like immutable types, except that const forms a
read-only view of data. Other aliases to that same data may
change it at any time."
I tried making an alias of a const variable and modifying it, but
that didn't work. So presumably they mean something else. The
only way I was able to get any kind of meaningful difference is
that for normal pointers and immutable pointers, I would get
errors if trying to get the address of non-normal or
non-immutable variables, respectively. By contrast, I could
assign an address of any of them (normal, const, immutable) to a
pointer to a constant variable.
Not sure when I would use this property, or if there are any
other relevant differences.
void main()
{
int x1 = 1;
const(int) x2 = 1;
immutable(int) x3 = 1;
int* p1_1 = &x1;
//int* p1_2 = &x2;
//int* p1_3 = &x3;
const(int)* p2_1 = &x1;
const(int)* p2_2 = &x2;
const(int)* p2_3 = &x2;
//immutable(int)* p3_1 = &x1;
//immutable(int)* p3_2 = &x2;
immutable(int)* p3_3 = &x3;
p1_1++;
//p1_2++;
//p1_3++;
p2_1++;
p2_2++;
p2_3++;
//p3_1++;
//p3_2++;
p3_3++;
}
