Vreemde definities van TRUE en FALSE macro’s

Ik heb de volgende macrodefinities in een codeerboek gezien.

#define TRUE  '/'/'/'
#define FALSE '-'-'-'

Er was daar geen uitleg.

Leg me uit hoe deze werken als TRUEen FALSE.

Antwoord 1, autoriteit 100%

Eens kijken: '/' / '/'betekent de charletterlijke /, gedeeld door de charletterlijke '/'zelf. Het resultaat is er één, die redelijk klinkt voor TRUE.

En '-' - '-'betekent de charletterlijke '-', afgetrokken van zichzelf. Dit is nul (FALSE).

Hier zijn twee problemen mee: ten eerste is het niet leesbaar. Het gebruik van 1en 0is absoluut beter. Zoals TartanLlama en KerrekSB hebben opgemerkt, moet je, als je die definitie ooit gaat gebruiken, haakjes eromheen toevoegen, zodat je niet voor verrassingen komt te staan:

#include <stdio.h>
#define TRUE  '/'/'/'
#define FALSE '-'-'-'
int main() {
        printf ("%d\n", 2 * FALSE);
        return 0;
}

Hiermee wordt de waarde van de charletterlijke '-'(45 op mijn systeem) afgedrukt.

Met haakjes:

#define TRUE  ('/'/'/')
#define FALSE ('-'-'-')

het programma drukt de nul correct af, ook al heeft het niet veel zin om een ​​waarheidswaarde te vermenigvuldigen met een geheel getal, maar het is slechts een voorbeeld van het soort onverwachte bugs dat u zou kunnen bijten als u uw macro’s niet tussen haakjes plaatst .

Antwoord 2, autoriteit 23%

Het is gewoon een andere manier van schrijven

#define TRUE 1
#define FALSE 0

De uitdrukking '/'/'/'deelt de char-waarde van '/'door zichzelf, wat 1 als resultaat geeft.

De uitdrukking '-'-'-'zal de char-waarde van '-'van zichzelf aftrekken, wat 0 als resultaat oplevert.

haakjes rond de hele define-expressies ontbreken echter, wat kan leiden tot fouten in de code met behulp van deze macro’s. Jay’s antwoordbeantwoordt dat redelijk goed.

Een voorbeeld van een “real-life” scenario waarbij het vergeten van de haakjes schadelijk kan zijn, is het gecombineerde gebruik van deze macro’s met een cast-operator in C-stijl. Als iemand besluit om deze uitdrukkingen naar boolin C++ te casten, bijvoorbeeld:

#include <iostream>
#define TRUE  '/'/'/'
#define FALSE '-'-'-'
int main() {
    std::cout << "True: " << (bool) TRUE << std::endl;
    std::cout << "False: " << (bool) FALSE << std::endl;
    return 0;
}

Dit is wat we krijgen:

True: 0
False: -44

Dus (bool) TRUEzou eigenlijk evalueren tot FALSE, en (bool) FALSEzou evalueren tot TRUE.

Antwoord 3, autoriteit 12%

Het staat gelijk aan schrijven

#define TRUE 1
#define FALSE 0

Wat de uitdrukking '/'/'/'eigenlijk doet, is het teken /(wat de numerieke waarde ook is) door zichzelf delen, zodat het 1.

Op dezelfde manier trekt de uitdrukking '-'-'-'het teken -van zichzelf af en evalueert het tot 0.

Het zou beter zijn om te schrijven

#define TRUE  ('/'/'/')
#define FALSE ('-'-'-')

om onbedoelde wijziging van waarden te voorkomen bij gebruik met andere operators met een hogere prioriteit.

Antwoord 4, autoriteit 9%

Jayheeft al geantwoord waarom de waarden van deze expressies 0en 1.

Voor de geschiedenis: deze uitdrukkingen '/'/'/'en '-'-'-'komen uit een van de items van 1e internationale verduisterde C-codewedstrijd in 1984:

int i;main(){for(;i["]<i;++i){ --i;}"];read('-'-'-',i+++"hell\
o, world!\n",'/'/'/'));}read(j,i,p){write(j/p+p,i---j,i/i);}

(Link naar het programma hier, er is een hint van wat dit programma doet op de IOCCC-pagina hierboven.)

Als ik me goed herinner, werden deze uitdrukkingen als versluierde macro’s voor TRUEen FALSEook behandeld in “Obfuscated C and Other Mysteries”boek van Don Libes (1993).

Antwoord 5, autoriteit 2%

Het is een hilarische manier om macro’s te schrijven voor TRUEen FALSE.

Omdat er veel uitleg is gegeven, betekent /een getal van 1 byte (volgens ASCII) wanneer het door zichzelf wordt gedeeld, het u 1geeft dat wordt behandeld als TRUEen eveneens -is opnieuw een bytegetal wanneer dezelfde waarde wordt afgetrokken, het geeft u 0die zal worden geïnterpreteerd als FALSE

#define TRUE  '/'/'/'
#define FALSE '-'-'-'

daarom kunnen we /of -vervangen door elk willekeurig teken dat we leuk vinden, bijvoorbeeld:

#define TRUE  '!'/'!'
#define FALSE 'o'-'o'

Behoudt dezelfde betekenis als de oorspronkelijke uitdrukking.

Antwoord 6, autoriteit 2%

Laten we beginnen met waar. Je kunt het lezen als '/' / '/', wat “teken ‘/’ gedeeld door teken ‘/'” betekent. Aangezien elk teken in C een numerieke waarde is (op één byte), kan het worden gelezen als “de ASCII-waarde van teken ‘/’ gedeeld door de ASCII-waarde van datzelfde teken”, wat 1 betekent (omdat, uiteraard, x/x is 1). Daarom is TRUE1.

Voor FALSEgeldt dezelfde redenering: '-'-'-'luidt '-' - '-', dwz ” de ASCII-waarde van ‘-‘ minus de ASCII-waarde van ‘-‘”, die 0 is. Daarom is FALSE0.

Dit is een nare manier om het voor de hand liggende te zeggen.