Re: Localized Variable Declaration

[David Rasmussen <pinkfloydhomer@yahoo.com>]

martin.m.dowie wrote:
> "David Rasmussen" <pinkfloydhomer@yahoo.com> wrote in message
> news:3CF77CDA.3090805@yahoo.com...
> 
>>Oh sure, but that is pretty tedious, compared to just a one line
>>variable declation. The point is, to be a bit extreme, that centralized
>>variable declations (e.g. at the "beginning" of the function) as done in
>>C and Pascal, are evil. Variables should be declared close to where they
>>are needed, IMO.
> 
> 
> Sure, but that's what you get with a declare ... begin ... end. You also get
> to delimit the scope in the example I gave there could have been 100 more
> lines after the 'end' that just didn't need visibility of the local
> variable. Can
> you do that with a 'one line variable declaration'?
> 
> 

You can do the same thing in C++ by just doing

int whatever(int foo)
{
     ...
     ...
     { // local scope starts here
          int local = 42;
          ....
     } // and ends here
     ...
}


very simple IMO.

So you can do the same in C++ as in Ada, and more. It's usually the 
other way around. And usually Ada has a good reason for doing things 
they way it does it. I just don't understand the justification for this 
limitation. Consider this:

void something()
{
     cout << "Write two numbers: ";
     int a;
     cin >> a;
     int b;
     cin >> b;
     double c = a * b * 42.42;
}

This demonstrates very much what I mean. Variables aren't declared until 
they can immediately be given a value, even by initialization or by some 
sort of assignment immediately after declaration. This is easier to read 
and understand and minimizes bugs with uninitialized values etc. Compare 
it to:

void something()
{
     int a,b;
     double c;

     cout << "Write two numbers: ";
     cin >> a;
     cin >> b;
     c = a * b * 42.42;
}

I admit that in this simple example, the second looks simpler, but 
still, the types of variables are taken away from the local place where 
they are used, and variables aren't initialized when they are declared. 
In larger functions and larger programs in general, it makes a 
difference. Now, of course this can be done in Ada with the declare 
block, but it will be much more tedious and harder to read.

/David