Problems with Mutex

[ketmar via Digitalmars-d-learn]

On Mon, 27 Oct 2014 02:07:09 +0200
ketmar via Digitalmars-d-learn <digitalmars-d-learn at puremagic.com>
wrote:

> > Thank you for clearing this up. If I understand correctly, 
> > __gshared is more of a hack to get C-like global variables, 
> > whilst shared is typed shared variable and more preferred?
> yes and no. 'shared' is the part of the type, while '__gshared' is
> not. i.e.
> 
>   shared int a;
>   pragma(msg, typeof(a)); // this will print "shared(int)"
> 
>   __gshared int b;
>   pragma(msg, typeof(b)); // this will print "int"
> 
> you can't freely mix shared and non-shared types, so you must cast
> 'shared' away on occasion and cast it back when necessary. this is not
> safe and error-prone.
> 
> '__gshared', for the other side, doesn't influence the type, so you
> can have global variable which can be passed to other functions
> without casting.
> 
> but yes, generally this is a hack, and you'd better avoid '__gshared'
> in idiomatic D code unless you are really really know what you are
> doing and what consequences it may have. ;-)
here is some silly code to show you some difference between 'shared'
and '__gshared':

  void foo (ref int i) {}

  int a;
  shared int b;
  __gshared int c;

  void main () {
    foo(a); // this compiles
    foo(b); // this will not compile (see below)
    foo(c); // this compiles too
  }

`foo(b);` will not compile, compiler emits error:
"Error: function y01.foo (ref int i) is not callable using argument
types (shared(int))"

if you'll change `foo` to `void foo (ref shared int i) {}`, you'll get
the opposite: `foo(a)` and `foo(c)` will be refused by compiler.
-------------- next part --------------
A non-text attachment was scrubbed...
Name: signature.asc
Type: application/pgp-signature
Size: 181 bytes
Desc: not available
URL: <http://lists.puremagic.com/pipermail/digitalmars-d-learn/attachments/20141027/33481f14/attachment.sig>