Dlaczego ta wersja logicznego AND w C nie wykazuje zachowania w postaci zwarcia?

Tak, to jest zadanie domowe, ale przeprowadziłem swoje badania i sporo przemyślałem na ten temat i nie mogę tego rozgryźć. Pytanie stwierdza, że ​​ten fragment kodu NIE wykazuje zachowania zwarciowego i pyta dlaczego. Ale wydaje mi się, że wykazuje zachowanie zwarciowe, więc czy ktoś może wyjaśnić, dlaczego tak nie jest?

W C:

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

Wydaje mi się, że w przypadku afałszu program w ogóle nie będzie próbował oceniać b, ale chyba się mylę. Dlaczego bw tym przypadku program w ogóle się styka , skoro nie musi?

To podchwytliwe pytanie. bjest argumentem wejściowym sc_andmetody, więc zawsze będzie obliczana. Innymi słowy sc_and(a(), b())zadzwoni a()i zadzwoni b()(zamówienie nie jest gwarantowane), a następnie zadzwoni sc_andz wynikami, a(), b()które przejdą do a?b:0. Nie ma to nic wspólnego z samym operatorem trójskładnikowym, który spowodowałby absolutne zwarcie.

AKTUALIZACJA

Jeśli chodzi o powód, dla którego nazwałem to „podchwytliwym pytaniem”: to z powodu braku dobrze zdefiniowanego kontekstu, w którym należy rozważyć „zwarcie” (przynajmniej tak, jak zostało to odtworzone w PO). Wiele osób, gdy podaje się tylko definicję funkcji, zakłada, że ​​kontekstem pytania jest pytanie o treść funkcji ; często nie traktują tej funkcji jako wyrażenia samej w sobie. Na tym polega „sztuczka” pytania; Aby przypomnieć, że w programowaniu w ogóle, ale szczególnie w językach takich jak C-like, które często mają wiele wyjątków od reguł, nie możesz tego zrobić. Przykład, jeśli pytanie zostało zadane jako takie:

Rozważmy następujący kod. Sc_and wykaże zachowanie zwarciowe, gdy zostanie wywołane z 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;
}

Byłoby to od razu jasne, że jesteś ma być myślenie sc_andjako operator w sobie w swoim własnym języku specyficzne dla domeny , i oceny, czy wezwanie do sc_andeksponatów zachowanie zwarcie jak regularna &&będzie . Nie uważałbym tego za podchwytliwe pytanie, ponieważ jasne jest, że nie powinieneś skupiać się na operatorze trójskładnikowym, a zamiast tego powinieneś skupić się na mechanice wywołań funkcji C / C ++ (i, jak sądzę, prowadzić ładnie do pytania uzupełniającego, aby napisać, sc_andże powoduje zwarcie, co wymagałoby użycia #defineraczej niż funkcji).

To, czy nazwiesz to, co sam operator trójskładnikowy wywołuje zwarciem (lub czymś innym, jak „ocena warunkowa”), zależy od twojej definicji zwarcia i możesz przeczytać różne komentarze, aby przemyśleć to. Według mnie tak jest, ale nie jest to szczególnie istotne dla rzeczywistego pytania lub dlaczego nazwałem to „sztuczką”.

Kiedy oświadczenie

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

executes, b++nie będzie oceniana, jeśli operand został aoszacowany na false(zachowanie w przypadku zwarcia). Oznacza to, że efekt uboczny bnie wystąpi.

Teraz spójrz na funkcję:

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

i nazwij to

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

W tym przypadku to, czy ajest, trueczy false, b++będzie zawsze oceniane ¹ podczas wywołania funkcji i bzawsze będzie miał miejsce efekt uboczny .

To samo dotyczy

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

i

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

_{1 Kolejność obliczania argumentów funkcji nie jest określona.}

Jak już zauważyli inni, bez względu na to, co zostanie przekazane do funkcji jako dwa argumenty, jest ona oceniana w miarę przekazywania. To jest na długo przed operacją dzierżawną.

Z drugiej strony to

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

spowodowałoby "zwarcie", ponieważ to makro nie implikuje wywołania funkcji, a przy tym nie jest wykonywana ocena argumentów funkcji.

Edytowano, aby poprawić błędy odnotowane w komentarzu @cmasters.

W

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

... returnwyrażenie ed wykazuje ocenę zwarcia, ale wywołanie funkcji nie.

Spróbuj zadzwonić

sc_and (0, 1 / 0);

Wywołanie funkcji oblicza 1 / 0, chociaż nigdy nie jest używane, powodując - prawdopodobnie - błąd dzielenia przez zero.

Odpowiednie fragmenty (projektu) normy ANSI C to:

2.1.2.3 Wykonanie programu

...

W maszynie abstrakcyjnej wszystkie wyrażenia są oceniane zgodnie z semantyką. Rzeczywista implementacja nie musi oceniać części wyrażenia, jeśli może wywnioskować, że jego wartość nie jest używana i że nie są wytwarzane żadne potrzebne efekty uboczne (w tym wszelkie spowodowane wywołaniem funkcji lub dostępem do obiektu ulotnego).

i

3.3.2.2 Wywołania funkcji

....

Semantyka

...

Przygotowując się do wywołania funkcji, argumenty są oceniane, a każdemu parametrowi przypisywana jest wartość odpowiadającego mu argumentu.

Domyślam się, że każdy argument jest oceniany jako wyrażenie, ale lista argumentów jako całość nie jest wyrażeniem, stąd zachowanie inne niż SCE jest obowiązkowe.

Jako rozpryskujący się na powierzchni głębokich wód standardu C doceniłbym odpowiednio poinformowany pogląd na dwa aspekty:

• Czy ocenianie 1 / 0powoduje niezdefiniowane zachowanie?
• Czy lista argumentów jest wyrażeniem? (Myślę, że nie)

PS

Nawet jeśli przejdziesz do C ++ i zdefiniujesz sc_andjako inlinefunkcję, nie otrzymasz SCE. Jeśli zdefiniujesz to jako makro C, tak jak robi to @alk , z pewnością to zrobisz.

Aby wyraźnie zobaczyć trójskładnikowe zwarcie op, spróbuj nieco zmienić kod, aby używać wskaźników funkcji zamiast liczb całkowitych:

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;
}

A potem skompiluj go (nawet prawie BEZ optymalizacji:! -O0). Zobaczysz, że b()nie jest wykonywany, jeśli a()zwróci false.

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

Tutaj wygenerowany montaż wygląda następująco:

    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:

Tak więc, jak słusznie wskazali inni, sztuczka polegająca na pytaniu polega na tym, abyś skupił się na trójskładnikowym zachowaniu operatora, który powoduje zwarcie (nazwij to „oceną warunkową”), zamiast oceny parametrów podczas wywołania (wezwanie według wartości), która NIE powoduje zwarcia.

Operator C trójskładnikowy nigdy nie zwarcie, ponieważ tylko jeden ocenia ekspresji (warunkiem), w celu określenia wartości podanej przez wyrażenia b i c , o ile może być zwrócony dowolna.

Poniższy kod:

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

Jest to prawie równoważne z następującym kodem:

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

Wyrażenie a może być utworzone przez inne operatory, takie jak && lub || które mogą spowodować zwarcie, ponieważ mogą oszacować dwa wyrażenia przed zwróceniem wartości, ale nie byłoby to traktowane jako operator trójskładnikowy powodujący zwarcie, ale operatory używane w warunku, tak jak w zwykłej instrukcji if.

Aktualizacja:

Trwa dyskusja, czy operator trójskładnikowy jest operatorem zwarcia. Argument mówi, że każdy operator, który nie ocenia wszystkich swoich operandów, wykonuje zwarcie zgodnie z @aruisdante w komentarzu poniżej. Gdyby podano tę definicję, operator trójskładnikowy byłby zwarty iw przypadku, gdy jest to oryginalna definicja, zgadzam się. Problem polega na tym, że termin „zwarcie” był pierwotnie używany w odniesieniu do określonego rodzaju operatora, który pozwalał na takie zachowanie i są to operatory logiczne / boolowskie, a powód, dla którego są tylko takie, postaram się wyjaśnić.

Zgodnie z artykułem Ocena zwarcia, ocena zwarcia odnosi się tylko do operatorów logicznych zaimplementowanych w języku w taki sposób, że wiedząc, że pierwszy argument sprawi, że drugi będzie nieistotny, to znaczy dla operatora && będącego pierwszym operandem fałszywym , a dla || operator jest pierwszym operandem, który jest prawdziwy , specyfikacja C11 zauważa to również w 6.5.13 Operator logiczny AND i 6.5.14 Operator logiczny OR.

Oznacza to, że aby zidentyfikować zachowanie zwarciowe, można by oczekiwać, że zostanie ono zidentyfikowane w operatorze, który musi ocenić wszystkie operandy, tak jak operatory boolowskie, jeśli pierwszy operand nie sprawia, że ​​drugi jest nieistotny. Jest to zgodne z tym, co jest napisane w innej definicji zwarcia w MathWorks w sekcji „Zwarcie logiczne”, ponieważ zwarcie pochodzi od operatorów logicznych.

Ponieważ próbowałem wyjaśnić operator trójskładnikowy, nazywany również trójskładnikowym, jeśli oblicza tylko dwa argumenty, oblicza pierwszy, a następnie ocenia drugi, jeden z dwóch pozostałych w zależności od wartości pierwszy. Robi to zawsze, nie powinno oceniać wszystkich trzech w żadnej sytuacji, więc w żadnym wypadku nie ma „zwarcia”.

Jak zawsze, jeśli zauważysz, że coś jest nie tak, napisz komentarz z argumentem przeciwko temu, a nie tylko negatywnym głosem, to tylko pogarsza wrażenia z SO i wierzę, że możemy być znacznie lepszą społecznością, która po prostu przegrywa z którym się nie zgadza.