Re: some questions re. Ada/GNAT from a C++/GCC user

[Mike Young <mikey@mcs.com>]

John G. Volan wrote:
> 
> In article <315AC5E7.3A77@escmail.orl.mmc.com>
> Ted Dennison, dennison@escmail.orl.mmc.com writes:
> 
> >If you want to declare variables later in the code just
> >use a declare block:
> >   declare
> >      Var1 : My_Type;
> >      ...
> >   begin
> >      Var1 := My_Value;
> >      ...
> >   end;
> >
> >This has the added benefit of limiting the scope of Var1 to the
> >begin..end  block of code.
> 
> There is another benefit, but it isn't obvious unless you take into
> account the concurrency aspects of Ada:
> 
> A C programmer would complain about having to introduce an extra
> begin/end block in order to introduce variables.  Isn't the scope
> of a variable well-defined in C, even without this extra baggage?
> It just extends from the declaration to the end of whatever block
> you're already in.
> 
> An Ada programmer would counter that, in Ada, some variables might be
> instances of _task_ types.  By definition, a task object gets created
> when its declaration is elaborated, but it does not get _activated_
> (i.e., it doesn't start executing its statements) until you hit the
> "begin" of the enclosing block.  This guarantees that everything in 

  [ ... some worthy thoughts snipped ... ]

> 
> C, of course, has no concurrency abstractions built in (nor does C++,
> last time I checked), so, gee, I guess this isn't an issue in C. :-)

============
Hmmmm. Lacking a language based synch method doesn't mean we always go 
straight to the semaphore library. I commonly use thin wrappers to guard 
precious resources -- for example: mutexes, semaphores, files, 
or database sessions. Local scoping allows precise control of lifetimes, 
and ensure release even when exceptions are possible:

void foo ()
{
   //-- some setup code here, perhaps
   ...
   {               // local scope
     LocalMutex<BazType> foo(mutexHandle);
     BazType & bar = foo.openResource();
     ...           // use the protected resource
   }               // end local scope. LocalMutex releases the resource
   ...
}