Що таке ідіоматичне використання довільних блоків у С?

Блок - це список операторів, які слід виконати. Приклади того, де блоки з’являються в C, є через деякий час і в операторах if

while( boolean expression)
    statement OR block

if (boolean expression)
    statement OR block

C також дозволяє вкладати блок в блок. Я можу використовувати це для повторного використання імен змінних, припустимо, мені дуже подобається "x"

int x = 0;
while (x < 10)
{
    {
        int x = 5;
        printf("%d",x)
    }
    x = x+1;
}

надрукує число 5 десять разів. Напевно, я міг бачити ситуації, коли бажано утримувати низьку кількість імен змінних. Можливо, в макророзширенні. Однак я не бачу жодної важкої причини, щоб потреба в цій функції. Чи може хто-небудь допомогти мені зрозуміти використання цієї функції, подавши деякі ідіоми, де вона використовується.

Ідея полягає не в тому, щоб кількість імен змінних змінюватись низькою чи іншим чином заохочувати повторне використання імен, а скоріше обмежувати область змінних. Якщо у вас є:

int x = 0;
//...
{
    int y = 3;
    //...
}
//...

то область дії yобмежується блоком, а це означає, що ви можете забути про нього перед або після блоку. Ви бачите, що це використовується найчастіше у зв’язку з петлями та умовними умовами. Ви також часто бачите це на мовах, подібних до С, таких як C ++, де змінна, що виходить за межі, спричиняє її руйнування.

Тому що за старих днів C нових змінних можна було оголосити лише в новому блоці.

Таким чином програмісти можуть вводити нові змінні в середину функції, не протікаючи її і мінімізуючи використання стеку.

З сучасними оптимізаторами це марно і знак того, що вам потрібно розглянути можливість вилучення блоку у власній функції.

У операторі перемикання корисно вкладати справи у власні блоки, щоб уникнути подвійного оголошення.

У C ++ це дуже корисно, наприклад, для охоронців блоку RAII та забезпечення деструкторів запускати фіксатор випуску, коли виконання виходить за рамки та все ще робить інші речі поза критичним розділом.

Я б не розглядав це як "довільні" блоки. Це не така функція, яка призначена настільки для використання розробниками, але те, як C використовує блоки, дозволяє використовувати ту саму конструкцію блоку в ряді місць з однаковою семантикою. Блок (на C) - це нова область, і змінні, що залишають його, усуваються. Це рівномірно незалежно від способу використання блоку.

В інших мовах це не так. Це має перевагу в тому, що дозволяє менше зловживань, як ви показуєте, але недолік, який блокують, поводиться по-різному в залежності від того, в якому контексті вони перебувають.

Я рідко бачив окремі блоки, що використовуються в C або C ++ - часто, коли є велика структура або об'єкт, який представляє з'єднання або щось, що ви хочете примусити знищити. Зазвичай це натяк на те, що ваша функція робить занадто багато речей і / або занадто довга.

Ви повинні усвідомити, що принципи програмування, які зараз здаються очевидними, не завжди були такими. Передовий досвід C значною мірою залежить від того, скільки вам років. Коли C вперше був введений, розбиття коду на невеликі функції вважалося занадто неефективним. Денніс Річі в основному збрехав і сказав, що виклики функцій були дійсно ефективними в C (їх тоді не було), через що люди почали їх більше використовувати, хоча програмісти на C-то чомусь ніколи не пройшли повну культуру передчасної оптимізації.

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

Однак я почав програмувати на C понад 20 років тому, тоді, коли вам довелося оголосити всі свої змінні у верхній частині області, і я не пригадую, щоб затінення змінних, як це колись, вважалося хорошим стилем. Повторне позначення в двох блоках один за одним, як у заяві перемикача, так, але не затінення. Можливо, якщо змінна вже була використана, а конкретне ім’я було дуже ідіоматичним для API, який ви викликаєте, наприклад, як destі srcв strcpy, наприклад.

Довільні блоки корисні для введення змінних посередників, які використовуються лише в особливих випадках обчислення.

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

1. покладатися на безліч параметрів або посередницьких величин;
2. доведеться мати справу з безліччю особливих справ.

З-за другого пункту корисно вводити тимчасові змінні з обмеженою сферою дії, що досягається більш сильно, використовуючи довільний блок або вводячи допоміжну функцію.

Хоча введення допоміжної функції може виглядати як нікому не відоме або найкраща практика сліпого слідування, насправді мало користі для цього в цій конкретній ситуації.

Оскільки існує велика кількість параметрів і посередницьких величин, ми хочемо ввести структуру для передачі їх до допоміжної функції.

Але, оскільки ми хочемо бути наслідком своєї практики, ми не будемо вводити лише одну допоміжну функцію, а декілька. Отже, чим раніше ми вводимо спеціальні структури, що передають параметри для кожної функції, які вводять багато накладних кодів для переміщення параметрів вперед і назад, або ми вводимо одну, яка буде керувати ними всіма структурою робочого листа, яка містить усі наші змінні, але виглядає як грайпак бітів без консистенції, де в будь-який час лише половина параметрів має цікаве значення.

Тому ці допоміжні структури, як правило, громіздкі, а їх використання означає вибір між кодовим розшаруванням або введення абстракції, сфера застосування якої занадто широка і послаблює значення програми, а не посилювати її .

Введення допоміжних функцій може полегшити одиничне тестування програми, запровадивши більш точну деталізацію тесту, але поєднуючи тестування одиниць для не тих процедур низького рівня та тестування регресії у вигляді порівнянь (з нумером) числових слідів процедур, є однаково хорошою роботою .

Взагалі повторне використання імен змінних таким чином викликає занадто велику плутанину у майбутніх читачів вашого коду. Краще просто назвати внутрішню змінну чимось іншим. Насправді мова C # спеціально забороняє використання змінних таким чином.

Я міг бачити, як використання вкладених блоків у розширеннях макросів буде корисним для запобігання зіткнень змінних імен.

Це для визначення речей, які зазвичай не мають сфери застосування на цьому рівні. Це вкрай рідко, і в цілому рефакторинг - кращий вибір, але я переживав це один-два рази в минулому в операторах переключення:

switch(foo) {
   case 1:
      {
         // bar
      }
   case 2:
   case 3:
      // baz
      break;
   case 4:
   case 5:
      // bang
      break;
}

Якщо ви розглядаєте технічне обслуговування, то їх рефакторинг повинен бути врівноваженим із виконанням всіх реалізацій підряд, доки кожна з них становить лише пару рядків. Зробити їх разом може бути простіше, ніж список імен функцій.

У моєму випадку, якщо я добре пригадую, більшість випадків були незначними варіаціями одного і того ж коду - за винятком того, що один з них був ідентичним іншому, лише з додатковою попередньою обробкою. Перемикач виявився найпростішою формою для прийняття коду, а додатковий обсяг дозволив використовувати додаткові локальні змінні, про які він і в подальших випадках не потрібно було турбуватися (наприклад, імена змінних, випадково перекриваючись одна з визначених перед комутатором, але використаний пізніше).

Зауважте, що оператор перемикання - це просто його використання. Я впевнений, що це може застосовуватися і в інших місцях, але я не пригадую, щоб їх ефективно використовували таким чином.