Блог

Я читал о области видимости переменных в C и столкнулся с интересной блочной структурой:

 int main(int argc, char **argv) {
    int local;

    { // New level of scope
        int more_local;
    }

    return 0;
}
  

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

Я также читал, что вызовы функций также помещают свои переменные в стек и завершаются в конце вызова, обозначаемого закрывающей фигурной скобкой } :

 void foo() {
    int more_local;
}

int main(int argc, char **argv) {
    int local;
    foo();

    return 0;
}
  

Как по-разному обрабатывается стек в обеих ситуациях и каковы преимущества и недостатки обеих?

С помощью вызова функции вы помещаете адрес возврата в стек и создаете новый фрейм стека. Если вы просто заключаете части кода в фигурные скобки, вы определяете новую область видимости, как вы сказали. Они похожи на любой блок кода, следующий за управляющим оператором, таким как if, for, while и т.д.

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

Ну, вы могли бы сказать, что ваш первый пример можно рассматривать как встроенную функцию. 😛
Но, как правило, вызовы функций и открытие нового scope не имеют ничего общего друг с другом.
Когда вы вызываете функцию, адрес возврата и все аргументы помещаются в накопленный файл и извлекаются из него после возврата функции.
При открытии нового scope вы просто вызываете деструктор всех объектов в пределах этой области в конце его; ни в коем случае не гарантируется, что фактическое пространство, занимаемое этими переменными, сразу же извлекается из стека. Это возможно, но пространство также может быть просто повторно использовано другими переменными в функции, в зависимости от прихотей компиляторов / оптимизаторов.

int more_local; в обоих случаях они будут помещены в стек. Но второй сценарий будет иметь накладные расходы на вызов функции.

Я бы посоветовал вам подумать об этом:

 void foo()
{
    int local;

    { // New level of scope
        int more_local_1;
    }
    { // New level of scope
        int more_local_2;
    }
}
  

Здесь more_local_1 и more_local_2 могут использоваться одни и те же ячейки памяти. Когда-то он использовался для
more_local_1 и во второй области видимости для more_local_2 переменной.

• локальные области по-прежнему могут обращаться к другим локальным переменным, в то время как функциям должна быть явно передана любая из переменных вызывающего объекта, которую они должны использовать

  • передача переменных — это проблема, но иногда это делает код более понятным, если четко указать меньший набор переменных, фактически необходимых для операций с ограниченной областью действия (а также поощрять группирование операций в отдельные функциональные блоки с присвоением соответствующего имени функции и имен параметров, соответствующих контексту, и затем они готовы к повторному использованию)

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

• по сравнению с областью действия функции локальные области особенно хороши для минимизации области действия переменных, содержащих важные ресурсы, такие как большие объемы памяти, потоки, файловые дескрипторы и / или блокировки: чем выше уровень и дольше выполняется функция, тем полезнее ее быстрая очистка

  • уменьшенное время жизни переменной также уменьшает количество параллельных переменных, которые программист должен мысленно «отслеживать», чтобы понять и поддерживать код: чем меньше, тем лучше

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

• локальные области немного неуклюжи и занимают «экранное пространство» в исходном коде, а также увеличивают уровень отступов, поэтому рекомендуется использовать их при наличии конкретного обоснования, а не по принципу «когда вы можете»

Если вы посмотрите на ассемблерный код для обеих программ, кажется, что разницы нет, потому что компилятор, похоже, генерирует ассемблерный код для выталкивания нового фрейма стека по текущему указателю стека, когда он сталкивается с открывающей фигурной скобкой или вызовом функции, и выталкивает фрейм, как только он сталкивается с закрывающей фигурной скобкой или оператором return.Преимущество во втором случае заключается в том, что вы можете возвращать значение с помощью инструкции return вызывающей функции. Но не в первом случае.