Confused about const

[Steven Schveighoffer]

On Fri, 19 Mar 2010 20:58:21 -0400, Paul D. Anderson  
<paul.d.removethis at comcast.andthis.net> wrote:

> I created a struct, call it "S", and some functions that operate on S.  
> But I'm confused about when const is useful.
>
> Being an old Java programmer, I use 'const' the same as I used 'final'  
> in Java. So most of my functions look like this:
>
> S for(const S a, const S b) {
>     S x = a;
>     S y = b;
>     // do some stuff
>     return a;
> }
>
> I declare the parameters const and then copy them to work on them.
>
> I get error messages about not implicitly casting const S to S. So I can  
> make an explicit cast:
>
>     S x = cast(S) a;
>     S y = cast(S) b;
>
> and the error messages go away.
>
> But I think I must have gone off the rails somewhere -- all I want is  
> for the caller to be sure the function doesn't alter a and b. But I end  
> up with lots of casts to/from const. What am I missing??


I'll try to help, const is a very complex thing to understand.  However,  
what it provides is so valuable for interface design that it is worth  
learning.

One thing to remember that const is transitive.  This means that if S  
contains a pointer to something, you have to treat that pointer as if it  
were const too.  This is a difference from Java's final.

If S has a pointer or reference, then a const S cannot be copied to a  
mutable S because you can then change the data through the mutable  
reference without any casts.  I'll give you an example:

struct S
{
   int *a;
}

void foo(const(S) s)
{
    S s2 = s; // this fails to compile because of the possibility for the  
next line.
    *s2.a = 5; // I now just changed the value pointed to by s, which is  
const data!
}

However, if S does not have a pointer or reference, then you can copy a  
const S to a mutable one because then changing the mutable S does not  
affect the const data in the original S.

example:

struct S
{
    int a;
}

void foo(const(S) s)
{
    S s2 = s; // this compiles
    s2.a = 5; // does not change s at all.
}

In answer to your question, what you are missing is what const is for.   
When declaring a function takes a const item, you are declaring that that  
function will not change the argument *or* anything it references.  The  
compiler is trying to enforce that.  Casting away const breaks the  
compiler guarantees, so you should not do that unless you know what you  
are doing.  So what I think is if you want to change the elements of S, or  
return an S parameter that is not const, then you shouldn't declare them  
as const parameters.

One final thing -- there is a brand new feature for D2 that allows you to  
forward the const attributes of parameters to return values.  This is  
under the heading "inout functions" of the documentation.  This feature is  
not implemented properly, even in the latest compiler.  However, once it  
does work, you can use it to declare your function like this:

inout(S) foo(inout(S) a, inout(S) b)
{
    return a;
}

What this means is, during the foo function, it will not modify a or b,  
but once it returns, the return value has the same constancy as the  
parameters.  It basically means "the const you put in is the const you get  
out."

-Steve