Какова цель анонимных {} блоки на языках стиля C?

Я использую его для блоков кода та потребность временные переменные.

Если Вы ограничены ANSI C, то они могли использоваться для объявления переменных ближе туда, где Вы используете их:

int main() {
    /* Blah blah blah. */
    {
        int i;
        for (i = 0; i < 10; ++i) {
        }
    }
}

Не необходимый с современным компилятором C все же.

Это об объеме, это относится к видимости переменных и методов в одной части программы к другой части той программы, рассмотрите этот пример:

int a=25;
int b=30;
{ //at this point, a=25, b=30
     a*=2; //a=50, b=30
     b /= 2; //a=50,b=15
     int a = b*b; //a=225,b=15  <--- this new a it's
                  //                 declared on the inner scope
}
//a = 50, b = 15

Обзор, конечно. (Что лошадь была избита до смерти уже?)

, Но если Вы смотрите на определение языка, Вы видите шаблоны как:

• , если ( выражение )   оператор
• , если ( выражение )   оператор   еще   переключатель оператора
• ( выражение )   оператор
• , в то время как ( выражение )   оператор
• делают   оператор   , в то время как ( выражение ) ;

Это упрощает синтаксис языка, что составной оператор является только одним из нескольких возможных оператор .

составной оператор :   { список оператора _{выбирают} }

список оператора :

• список оператора оператора
•   оператор оператора

:

• блок попытки оператора объявления
• оператора перехода
оператора цикла
оператора выбора
составного оператора
оператора выражения
помеченного оператора

Как предыдущие упомянутые плакаты, это ограничивает использование переменной к объему, в котором это объявляется.

На собравших "мусор" языках, таких как C# и Java, это также позволяет сборщику "мусора" исправлять память, используемую любыми переменными, используемыми в объеме (хотя установка в NULL переменных имела бы тот же эффект).

{
    int[] myArray = new int[1000];
    ... // Do some work
}
// The garbage collector can now reclaim the memory used by myArray

Они очень часто используются для обзора переменных, так, чтобы переменные были локальны для произвольного блока, определенного фигурными скобками. В Вашем примере переменные i и k не доступны за пределами их фигурных скобок включения, таким образом, они не могут быть изменены никакими подлыми способами, и что те имена переменной могут быть снова использованы в другом месте в Вашем коде. Другое преимущество для использования фигурных скобок для создания локального объема как это - то, что на языках со сборкой "мусора", сборщик "мусора" знает, что безопасно очистить переменные из объема. Это не доступно в C/C++, но я полагаю, что это должно быть в C#.

Один простой способ думать об этом состоит в том, что фигурные скобки определяют атомарную часть кода, отчасти как пространство имен, функция или метод, но не имея необходимость на самом деле создавать пространство имен, функцию или метод.

Насколько я понимаю, они просто для обзора. Они позволяют Вам именам переменной повторного использования в объемах родителя/одноуровневого элемента, которые могут время от времени быть полезными.

РЕДАКТИРОВАНИЕ: Этот вопрос был на самом деле отвечен на другой вопрос Переполнения стека . Надежда, которая помогает.

Путем создания нового объема они могут использоваться для определения локальных переменных в операторе переключения.

, например,

switch (i)
{
    case 0 :
        int j = 0;   // error!
        break;

по сравнению с

switch (i)
{
    case 0 :
    {
        int j = 0;   // ok!
    }
    break;

{ ... } открывает новый объем

В C++, можно использовать их как это:

void function() {
    // ...
    {
        // lock some mutex.
        mutex_locker lock(m_mutex);
        // ...
    }
    // ...
}

, После того как управление выходит из блока, взаимоисключающий блокировщик уничтожается. И в его деструкторе, это автоматически разблокировало бы взаимное исключение, с которым это подключено. Это очень часто делают и называют RAII (приобретение ресурса является инициализацией), и также SBRM (объем связанное управление ресурсами). Другое распространенное приложение должно выделить память, и затем в деструкторе, свободном та память снова.

Другая цель состоит в том, чтобы сделать несколько подобных вещей:

void function() {
    // set up timer A
    {
        int config = get_config(TIMER_A);
        // ... 
    } 

    // set up timer B
    {
        int config = get_config(TIMER_B);
        // ...
    } 
}

Это разделит вещи, таким образом, можно будет легко узнать различные стандартные блоки. Можно использовать переменные, имеющие то же имя, как код делает выше, потому что они не видимы вне своего объема, таким образом они не конфликтуют друг с другом.

class ExpensiveObject {
public:
    ExpensiveObject() {
        // acquire a resource
    }
    ~ExpensiveObject() {
        // release the resource
    }
}

int main() {
    // some initial processing
    {
        ExpensiveObject obj;
        // do some expensive stuff with the obj
    } // don't worry, the variable's scope ended, so the destructor was called, and the resources were released
    // some final processing
}

Другое общее использование с OpenGL glPushMatrix() и glPopMatrix() функции для создания логических блоков, касающихся матричного стека:

glPushMatrix();
{
    glTranslate(...);
    glPushMatrix();
    {
        glRotate(...);
        // draw some stuff
    }
    glPopMatrix();
    // maybe draw some more stuff
}
glPopMatrix();

Они часто полезны для RAII цели, что означает, что данный ресурс будет выпущен, когда объект выйдет из объема. Например:

void function()
{
    {
        std::ofstream out( "file.txt" );
        out << "some data\n";
    }
    // You can be sure that "out" is closed here
}

Скобки определяют область объема - что-либо объявленное в скобках невидимо за пределами них.

, Кроме того, в C++ объект, выделенный на стеке (например, без использования 'новых'), будет разрушен, когда это выйдет из объема.

В некоторых случаях это может также быть способ выделить конкретную часть функции, которую чувствует автор, достойно внимания для людей, смотрящих на источник. Является ли это хорошим использованием или не спорно, но я видел сделанный.

Вы делаете две вещи.

1. Вы вызываете ограничение объема на переменные в том блоке.
2. Вы позволяете одноуровневым блокам кода использовать те же имена переменной.