In my code you may find things like:
//C

int getSomeElement(){  int i; for (i=0;i<10;i++)  {    if (i==5) return i;  }}

i use scopes in my cases for switch also

//C#

switch (i){  case 0:  {    ArrayList al = Database.Query("select * from mytable1");    foreach (object[] obj in al) {}    break;  }  case 1:  {    ArrayList al = Database.Query("select * from mytable2");    foreach (object[] obj in al) {}    break;  }}

To show i can now use the same variable in multiple cases...

Quote:Original post by richardurich
Most people I have encountered had an easier time learning with the second style, but everyone seems to eventually move to the first. I doubt it's always for the same reason I did, so maybe it's more information fitting on a single screen/page or just people adapting to the norm.

I actually started out with the second style, then moved to the first style for the same reason as you. But i recently went back to the second again. I trained myself to type the closing bracket of the scope first before writing the internals. I start like:

public void DoSomething(){}

and then i move on:

public void DoSomething(){  ArrayList al = GetMeAFancyList();  foreach (object item in al)  {  }}

now fill in the code of the foreach scope.
It helps me when i go many levels deep while writing lots of code (i had to do some calculations over a 9 dimension array once). Because before i did this i found myself ending my function with a load of closing brackets hoping for the best :)

Greetings.

style #1 is good for its tendency to properly bind things together. Notice how the else statement tightly binds the two potential blocks together.

void doesSomething(int x) {    if (x) {        // stuff    } else {        // stuff    }}

With style #1, do/while loops are tightly integrated with the block structure.

void doesSomething(int x) {    do {        // stuff    } while (--x > 0);}

Under style #2, it becomes difficult to differentiate a do/while loop from an empty while loop; the integration is much looser.

void doesSomething(int x) {    do    {        // stuff    }    while (--x > 0);}

The same problem comes up with for loops, as richardurich mentioned. Under style #2, if you remove the for line, the code will remain meaningful, but with a different meaning. The code is written as if the for line were a sibling of the brace line while, as far as the meaning is concerned, they basically the same. Actually, the brace takes the place of the single expression after the conditional to create the multi-expression block, so it should either be indented or placed on the same line.

void doesSomething(int x){    for (int i; i < x; ++i) x--;    {        int x;        // stuff    }}

Orphaned scopes can be useful for avoiding pollution. With style #1, they are easy to recognize. Under style #2, they could easily be mistaken for a loop, as in the previous example.

However, single expressions after conditionals (is there a correct word for these?) are harder to recognize under style #1, especially if the conditional is really long.

void doesSomething(int x) {    if (x != 1 && ...) // pretend this conditional extends out of view        x = 0;    if (x != 1 && ...) { // pretend this conditional extends out of view        x = 0;    } // your only clue is the closing brace}

[Edited by - dcosborn on August 20, 2006 1:03:27 PM]

in my opinion, the first style just looks cluttered and a little less easily understood. i really dont know where that style came around from, i had never seen it until i started programming in Java, and even then it wasn't the way it was taught in my school.

it makes me think that it was possibly an adaptation of style from another language like visual basic, where code always starts on the next line, except for END statements (analgous to a closing bracket).

You've gotta be flexable, many companies will have coding guidelines which will specify this sorta thing.

I used to use OP's #1, but where I've worked for the last 2 years uses OP's #2, so that's what I use now.