Чому ця версія логічного І на С не відображає поведінку короткого замикання?

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

У C:

int sc_and(int a, int b) {
    return a ? b : 0;
}

Мені здається, що у aхибному випадку програма взагалі не намагатиметься оцінити b, але я повинен помилятися. Чому програма взагалі торкається bв цьому випадку, коли цього не потрібно?

Це питання фокусу. bє вхідним аргументом sc_andметоду, і тому завжди буде оцінюватися. Іншими словами, sc_and(a(), b())буде дзвонити a()і дзвонити b()(замовлення не гарантоване), потім дзвоніть sc_andз результатами a(), b()якого переходить на a?b:0. Це не має нічого спільного з самим трикомпонентним оператором, який би абсолютно замикав.

ОНОВЛЕННЯ

Що стосується того, чому я назвав це "фокусним запитанням": це через відсутність чітко визначеного контексту, де слід розглядати "коротке замикання" (принаймні, як відтворено ОП). Багато людей, отримуючи лише визначення функції, припускають, що контекст питання задає питання про суть функції ; вони часто не розглядають функцію як вираз сам по собі. Це «фокус» питання; Щоб нагадати вам, що в програмуванні загалом, але особливо в таких мовах, як C-like, які часто мають багато винятків із правил, цього робити не можна. Приклад, якщо запитання було задано як таке:

Розглянемо наступний код. Sc_and покаже поведінку короткого замикання при виклику з main :

int sc_and(int a, int b){
    return a?b:0;
}

int a(){
    cout<<"called a!"<<endl;
    return 0;
}

int b(){
    cout<<"called b!"<<endl;
    return 1;
}

int main(char* argc, char** argv){
    int x = sc_and(a(), b());
    return 0;
}

Було б відразу зрозуміло , що ви повинні думати про sc_andякість оператора в і самому по собі в своєму власному предметно-орієнтованої мови , і оцінках , якщо виклик sc_andекспонати короткого замикання поведінки як звичайний &&буде . Я б не вважав це питанням хитрості взагалі, тому що зрозуміло, що ви не повинні зосереджуватися на потрійному операторі, а натомість повинні зосередитися на механіці викликів функцій C / C ++ (і, я гадаю, привести добре в наступне запитання, щоб написати sc_andкоротке замикання, яке передбачає використання, #defineа не функції).

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

Коли заява

bool x = a && b++;  // a and b are of int type

виконується, b++не буде обчислюватися, якщо операнд aоцінений false(поведінка короткого замикання). Це означає, що побічний ефект bне відбудеться.

Тепер погляньмо на функцію:

bool and_fun(int a, int b)
{
     return a && b; 
}

і зателефонуйте цьому

bool x = and_fun(a, b++);

У цьому випадку, aє trueчи false, b++завжди буде оцінюватися ¹ під час виклику функції, і побічний ефект на bзавжди матиме місце.

Те саме стосується і

int x = a ? b : 0; // Short circuit behavior 

і

int sc_and (int a, int b) // No short circuit behavior.
{
   return a ? b : 0;
} 

_{1 Порядок оцінки аргументів функції не вказаний.}

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

З іншого боку, це

#define sc_and(a, b) \
  ((a) ?(b) :0)

б «коротке замикання», так як це макро не означає виклик функції і з цим немає оцінок аргументу функції , (S) виконуються.

Відредаговано для виправлення помилок, зазначених у коментарі @cmasters.

В

int sc_and(int a, int b) {
    return a ? b : 0;
}

... returnвираз ed відображає оцінку короткого замикання, але виклик функції - ні.

Спробуйте зателефонувати

sc_and (0, 1 / 0);

Виклик функції обчислює 1 / 0, хоча він ніколи не використовується, отже, викликаючи - ймовірно - помилку ділення на нуль.

Відповідними витягами із (проекту) стандарту ANSI C є:

2.1.2.3 Виконання програми

...

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

і

3.3.2.2 Виклики функцій

....

Семантика

...

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

Я припускаю, що кожен аргумент оцінюється як вираз, але що список аргументів у цілому не є виразом, отже, поведінка, що не стосується SCE, є обов’язковою.

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

• Чи дає оцінка 1 / 0невизначену поведінку?
• Список аргументів - це вираз? (Я думаю, що не)

PS

Навіть якщо ви перейдете на C ++ і визначите sc_andяк inlineфункцію, ви не отримаєте SCE. Якщо ви визначите його як макрос C, як це робить @alk , ви, звичайно, зробите.

Щоб чітко побачити тернарне коротке замикання, спробуйте трохи змінити код, використовуючи вказівники на функції замість цілих чисел:

int a() {
    printf("I'm a() returning 0\n");
    return 0;
}

int b() {
    printf("And I'm b() returning 1 (not that it matters)\n");
    return 1;
}

int sc_and(int (*a)(), int (*b)()) {
    a() ? b() : 0;
}

int main() {
    sc_and(a, b);
    return 0;
}

А потім скомпілюйте його (навіть майже без оптимізації -O0!). Ви побачите b(), що не виконується, якщо a()повертає false.

% gcc -O0 tershort.c            
% ./a.out 
I'm a() returning 0
% 

Тут згенерована збірка виглядає так:

    call    *%rdx      <-- call a()
    testl   %eax, %eax <-- test result
    je      .L8        <-- skip if 0 (false)
    movq    -16(%rbp), %rdx
    movl    $0, %eax
    call    *%rdx      <- calls b() only if not skipped
.L8:

Отож, як інші правильно вказали на фокус із питанням, змусити вас зосередитись на поведінці тернарного оператора, який РОЗВІДАЄ коротке замикання (виклик, що називається «умовною оцінкою»), а не на оцінку параметрів під час виклику (виклик за значенням), який НЕ робить короткого замикання.

C-потрійний оператор ніколи не може здійснити коротке замикання, оскільки він обчислює лише один вираз a (умова), щоб визначити значення, задане виразами b і c , якщо якесь значення може бути повернуте.

Наступний код:

int ret = a ? b : c; // Here, b and c are expressions that return a value.

Це майже еквівалентно наступному коду:

int ret;
if(a) {ret = b} else {ret = c}

Вираз a може бути сформований іншими операторами, такими як && або || це може призвести до короткого замикання, оскільки вони можуть обчислити два вирази перед тим, як повернути значення, але це не буде розглядатися як тернарний оператор, що робить коротке замикання, а оператори, що використовуються в умові, як це робиться у звичайному операторі if.

Оновлення:

Існують певні суперечки щодо тернарного оператора як оператора короткого замикання. Аргумент говорить, що будь-який оператор, який не оцінює всі свої операнди, робить коротке замикання відповідно до @aruisdante у коментарі нижче. Якби дано це визначення, тоді тернарний оператор мав би коротке замикання, і у випадку, якщо це оригінальне визначення, я згоден. Проблема полягає в тому, що термін "коротке замикання" спочатку використовувався для певного типу оператора, який допускав таку поведінку, а це логічні / логічні оператори, і тому я спробую пояснити причину, чому саме такі.

Після статті Оцінка короткого замикання, оцінка короткого замикання стосується лише булевих операторів, реалізованих у мові таким чином, що, знаючи, що перший операнд зробить другий неактуальним, це означає, що оператор && є першим операндом помилковим , а для || Оператор є першим операндом true , специфікація C11 також зазначає це в 6.5.13 Оператор логічного І та 6.5.14 Оператор логічного АБО.

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

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

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