Де можна, а що не можна оголошувати нові змінні в C?

Question 1

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

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

if (n > 0){
    int i;
    for (i=0;i<n;i++)
    ...
}

Я трохи погрався з концепцією, і вона працює навіть з масивами. Наприклад:

int main(){
    int x = 0 ;

    while (x<10){
        if (x>5){
            int y[x];
            y[0] = 10;
            printf("%d %d\n",y[0],y[4]);
        }
        x++;
    }
}

То коли саме мені не дозволяється оголошувати змінні? Наприклад, що робити, якщо моя декларація змінної не відповідає одразу після відкриття фігурної дужки? Як тут:

int main(){
    int x = 10;

    x++;
    printf("%d\n",x);

    int z = 6;
    printf("%d\n",z);
}

Чи може це спричинити проблеми залежно від програми / машини?

Question 2

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

Незважаючи на те, що всі версії C дозволяють використовувати лексичний обсяг блоків, де ви можете оголосити змінні залежно від версії стандарту C, на яку ви націлюєтеся:

C99 або C ++

Сучасні компілятори C, такі як gcc і clang, підтримують стандарти C99 і C11 , які дозволяють оголошувати змінну куди завгодно. Область дії змінної починається з точки оголошення до кінця блоку (наступна закриваюча дужка).

if( x < 10 ){
   printf("%d", 17);  // z is not in scope in this line
   int z = 42;
   printf("%d", z);   // z is in scope in this line
}

Ви також можете оголосити змінні всередині для ініціалізаторів циклу. Змінна буде існувати лише всередині циклу.

for(int i=0; i<10; i++){
    printf("%d", i);
}

ANSI C (C90)

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

Це не означає, що ви повинні оголосити всі свої змінні у верхній частині своїх функцій. У C ви можете поставити блок, розділений фігурними дужками, куди завгодно може піти висловлювання (не лише після речей, таких як ifor for), і ви можете використовувати це для введення нових змінних областей. Далі наведена версія ANSI C попередніх прикладів C99:

if( x < 10 ){
   printf("%d", 17);  // z is not in scope in this line

   {
       int z = 42;
       printf("%d", z);   // z is in scope in this line
   }
}

{int i; for(i=0; i<10; i++){
    printf("%d", i);
}}

¹ Зверніть увагу, що якщо ви використовуєте gcc, вам потрібно передати --pedanticпрапор, щоб він фактично застосував стандарт C90, і поскаржитися на те, що змінні оголошені не в тому місці. Якщо ви просто використовуєте -std=c90це, змушує gcc приймати надмножину C90, що також дозволяє більш гнучкі декларації змінних C99.

Question 3

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

Візьмемо наступний код як приклад.

#include <stdio.h>

int main() {
    int i, j;
    i = 20;
    j = 30;

    printf("(1) i: %d, j: %d\n", i, j);

    {
        int i;
        i = 88;
        j = 99;
        printf("(2) i: %d, j: %d\n", i, j);
    }

    printf("(3) i: %d, j: %d\n", i, j);

    return 0;
}

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

(1) i: 20, j: 30
(2) i: 88, j: 99
(3) i: 20, j: 99

По-перше, ми призначаємо 20 і 30 відповідно iі j. Потім, всередині фігурних дужок, ми призначаємо 88 і 99. Отже, чому ж тоді значення jзберігає значення, але iзнову повертається до значення 20? Це через дві різні iзмінні.

Між внутрішнім набором фігурних дужок iзмінна зі значенням 20 прихована і недоступна, але оскільки ми не оголосили нову j, ми все ще використовуємо jз зовнішньої області. Коли ми залишаємо внутрішній набір фігурних дужок, iзберігання значення 88 зникає, і ми знову маємо доступ до значення iзі значенням 20.

Іноді така поведінка - це добре, інколи, можливо, ні, але повинно бути зрозуміло, що якщо ви користуєтеся цією функцією C без розбору, ви дійсно можете зробити свій код заплутаним і важким для розуміння.

Question 4

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

Question 5

Допис містить такий код:

//C99
printf("%d", 17);
int z=42;
printf("%d", z);

//ANSI C
printf("%d", 17);
{
    int z=42;
    printf("%d", z);
}

і я думаю, що це означає, що вони рівнозначні. Вони не є. Якщо int z розміщено внизу цього фрагмента коду, це спричиняє помилку перевизначення щодо першого визначення z, але не проти другого.

Однак кілька рядків:

//C99
for(int i=0; i<10; i++){}

працює. Показано тонкощі цього правила C99.

Особисто я пристрасно уникаю цієї функції C99.

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

Question 6

Відповідно до мови програмування C від K&R -

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

Тут ви можете побачити слово, як правило, це не обов'язково ..

Question 7

З clang і gcc я зіткнувся з основними проблемами з наступним. версія gcc 8.2.1 20181011 clang версія 6.0.1

  {
    char f1[]="This_is_part1 This_is_part2";
    char f2[64]; char f3[64];
    sscanf(f1,"%s %s",f2,f3);      //split part1 to f2, part2 to f3 
  }

жоден компілятор не любив f1, f2 чи f3, щоб бути в блоці. Мені довелося перенести f1, f2, f3 в область визначення функції. компілятор не заперечував визначення цілого числа з блоком.

Question 8

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

Для розподілу речей у стеку, ЦП має два спеціальні регістри, один називається покажчиком стека (SP), а інший - базовим покажчиком (BP) або покажчиком кадру (мається на увазі, що кадр стека локальний до поточної області функцій). SP вказує на поточне розташування у стеці, тоді як BP вказує на робочий набір даних (над ним) та аргументи функції (під ним). Коли функція викликається, вона штовхає BP виклику / батьківської функції у стек (вказаний SP) і встановлює поточний SP як новий BP, потім збільшує SP на кількість байтів, пролитих з регістрів на стек, робить обчислення , а після повернення він відновлює АТ свого батька, витягуючи його зі стека.

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

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

Суворий стандарт C99 вимагає явного {перед оголошеннями, тоді як розширення, введені C ++ та GCC, дозволяють декларувати vars далі в тілі, що ускладнює gotoта caseтвердження. C ++ додатково дозволяє оголошувати речі всередині для ініціалізації циклу, що обмежується сферою дії циклу.

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

TLDR: використання, {}щоб явно вказати область змінних, може допомогти як компілятору, так і користувачеві.