When do you use code blocks?

When do you use code blocks in C/C++/C#, etc.? I know the theoretical reason behind them, but when do you use them in real programs?

EDIT: I have just realised that I use them in switch statements, where variables would otherwise be in the same scope (grr for things like i):

switch (x) { case "abc": { /* code */ } break; }

etc (Just to clarify, in a switch statement, the extra braces are NOT required.)

---

Related:

• Do you use curly braces for additional scoping? (http://stackoverflow.com/questions/249009/do-you-use-curly-braces-for-additional-scoping)

From stackoverflow

• You can get a finally like behavior in C++ by using code blocks and RAII objects.

  {
     std::fstream f(filename)
     ...
  }
  

  will release the file descriptor in the destructor no matter what causes us to leave the block.

  (Personally, I'm still trying to make a practice of this. My c roots hold a death grip on my habits...)

  Matt Kane : You can also use this: Make a wrapper object around a synchronization primitive and put that on a stack in the block you need protected. This way you can't forget to release the lock.

• In addition to the obvious ("when required by syntax", like in a switch or a try catch finally),
  Whenever you need to treat a block of 2 or more statements as an atomic unit

• I do the same thing with switch blocks, even though it isn't required. In general, I use code blocks where they either make code more readable (whether that's through giving similar blocks of code a similar appearance or just getting the indenting) or they properly scope variables.

• I sometimes, but rarely, use naked code blocks to limit scope. For example, take the following code:

  double bedroomTemperature = ReadTemperature(Room.Bedroom);
  database.Store(Room.Bedroom, bedroomTemperature);
  
  double bathroomTemperature = ReadTemperature(Room.Bathroom);
  database.Store(Room.Bedroom, bedroomTemperature);
  

  The code looks fine at first glance, but contains a subtle copy-pasta error. In the database we have stored the bedroom temperature for both readings. If it had been written as:

  {
      double bedroomTemperature = ReadTemperature(Room.Bedroom);
      database.Store(Room.Bedroom, bedroomTemperature);
  }
  
  {
      double bathroomTemperature = ReadTemperature(Room.Bathroom);
      database.Store(Room.Bedroom, bedroomTemperature);
  }
  

  Then the compiler (or even IDE if it is intelligent enough) would have spotted this.

  However, 90% of the time the code can be refactored to make the naked blocks unnecessary, e.g. the above code would be better written as a loop or two calls to a method that reads and stores the temperature:

  foreach (Room room in [] { Room.Bedroom, Room.Bathroom })
  {
      double temperature = ReadTemperature(room);
      database.Store(room, temperature);
  }
  

  Naked blocks are useful on occasion though.