[static] [shared] [const|immutable]

[Christopher Wright]

Lionello Lunesu wrote:
> 
> "Christopher Wright" <dhasenan at gmail.com> wrote in message 
> news:gugs7b$70p$1 at digitalmars.com...
>> Lionello Lunesu wrote:
>>> I like shared/const/immutable as much as the next guy, but there are 
>>> now 2x2x3=12 ways to decorate a variable. Furthermore, by either 
>>> declaring the variable globally or locally (stack), we end up with 24 
>>> possible declaration. See the code at the end of this post.
>>
>> The decision to make a variable a static class or module member is 
>> independent of whether to make it shared or not.
> 
> You're right, of course. I realize now that "static" is a storage class 
> (when used locally) not a type modifier.
> 
>> Shared and const-level have to do with controlling access to the 
>> variable.
>>
>> An immutable variable does not need to be declared shared.
> 
> So, immutable implies shared.

Immutable is threadsafe. Shared implies automatic locking, I believe; 
immutable variables do not need any locking.

>> Shared const is for publish-subscribe sort of deals.
> 
> You mean one thread can change the value, but for another thread it's 
> constant? I can see how it would be useful using reference types, but I 
> don't understand how it would work with value types..

Shared const doesn't really work for value types; it ends up being the 
same as immutable. Unless you have a mutable pointer to the value, in 
which case you can write to the value through that pointer. That is not 
safe -- the compiler is free to see that this variable is const and a 
value type, which means you can't ever write to it, and then put it in 
read-only memory.

Const that doesn't boil down to immutable works a fair bit better with 
object-oriented code. You wrap your value in a class, create a mutable 
instance, and send it to a bunch of other functions or objects or 
threads expecting a const object. They can't use the mutators, but they 
can use the accessors.

>> Shared mutable is for cooperative writing to the variable.
> 
> This one I understood :)
> 
>> The point of a shared local variable is to pass it to another thread 
>> or set of threads, which will then be able to mutate it without trouble.
> 
> As before, how can an int (value type) on the stack ever be shared with 
> another thread? It would always have to be copied... Can you give me an 
> example please?

By reference.

int i;
shared int* j = &i;
sendToManyThreads(j);