Czy możemy pisać komentarze w nazwach zmiennych?

int main()
{
     i/*nt*/a = 10;
     return 0;
}

Jeśli mam powyższy kod i chcę policzyć tokeny, czy będzie to 14 czy 13 tokenów?

Czy wpisywanie komentarza w nazwie zmiennej jest poprawne? Można założyć, że int i, int a, int iasą zdefiniowane globalnie.

Komentarze są usuwane podczas fazy 3 tłumaczenia programu ¹ : każdy komentarz jest zastępowany jedną spacją. więc komentarz /*nt*/zdecydowanie nie jest znakiem.

Jeśli żadna z int, main, i, alub returnsą zdefiniowane jako przerób makr, analizowania program produkuje 14 znaki (nie 13):

int main ( ) { i a = 10 ; return 0 ; }

O ile nie ijest zdefiniowany jako typ z typedefinstrukcją, występuje błąd składniowy, ponieważ i anie pasuje do reguły w gramatyce C.

Dlatego nie możesz wpisywać komentarzy w nazwach zmiennych, komentarz dzieli identyfikator na 2 oddzielne tokeny. To jest prawdziwe dla dowolnej wyprzedzającym i języka C tokena ² .

Zwróć jednak uwagę, że możesz wstawiać komentarze w nietypowych miejscach, takich jak między operatorami jednoargumentowymi a ich operandami lub między #dyrektywą a preprocessing i jej argumentami:

/**/#/**/include/**/<stdio.h>/**///////////////////////
/**/#/**/define/**/STAT/**/(/**/a/**/)/**/-/**/1/**////
/**/#/**/ifdef/**/STAT/**//////////////////////////////
/**/int/**/main/**/(/**/)/**/{/**//////////////////////
/**/int/**/a/**/=/**/+/**/1/**/;/**////////////////////
/**/printf/**/(/**/"Hello "/**/"world!\n"/**/)/**/;/**/
/**/return/**/STAT/**/;/**/////////////////////////////
/**/}/**///////////////////////////////////////////////
/**/#/**/endif/**//////////////////////////////////////

Ale powyższa definicja makra nie definiuje makra podobnego do funkcji, ale zwykłe makro, STATktóre rozwija się do ( a ) - 1.

Nazwy zmiennych, jak każdy inny token, można podzielić za pomocą znaków nowej linii. Znaki nowej linii to sekwencje lub \bezpośrednio po nich następuje nowa linia. Sekwencje te są usuwane z kodu źródłowego podczas fazy 2 tłumaczenia programu. Ich głównym celem jest złamanie długich definicji makr w wielu wierszach.

Poniżej znajduje się fragment kodu ^3, który generuje te same 14 tokenów:

\
i\
nt\
 ma\
in()
{\
i/\
*nt\
*/a \
= 10;
r\
et\
urn\
 0;}

Zwróć uwagę, jak kolorizator kodu pomijał słowa kluczowe pokrojone w plasterki i kostkę oraz komentarz :)

_{1) To zachowanie zostało określone w ANSI-C aka C89. Niektórzy starożytni kompilatorzy zachowywali się nieco inaczej, co skutkowało wklejaniem znaczników, ale takie osobliwości mają jedynie znaczenie historyczne.}

_{2) Możesz prawie wstawić komentarz wewnątrz stałej łańcuchowej, wykorzystując fakt, że sąsiednie stałe łańcuchowe są konkatenowane w fazie 6 tłumaczenia programu: printf("Hello "/* my name is Luca */"world!\n");}

_{3) Ten styl prezentacji Choinka nie jest przeznaczony do użytku w prawdziwych programach, ilustruje, jak nadużywać możliwości obsługi wejścia C. Bardziej wyszukane sztuczki wygrały Międzynarodowy konkurs na zaciemniony kod C.}

Z leksykalnego punktu widzenia komentarz jest tym samym, co biały znak.

Sekcja 6.4p3 normy C dotycząca elementów leksykalnych stwierdza:

... Tokeny przetwarzania wstępnego można oddzielić białymi znakami ; składa się z komentarzy (opisanych później) lub znaków odstępu (spacja, tabulator poziomy, nowa linia, tabulator pionowy i wysuw strony) lub obu. ...

Mówiąc dokładniej, komentarz jest tłumaczony na pojedyncze miejsce. Jest to określone w sekcji 5.1.1.2p3:

Plik źródłowy jest dekomponowany na tokeny przetwarzania wstępnego i sekwencje znaków odstępu (w tym komentarze). Plik źródłowy nie może kończyć się tokenem częściowego przetwarzania wstępnego ani częściowym komentarzem. Każdy komentarz jest zastępowany jednym znakiem spacji. Znaki nowego wiersza są zachowywane. To, czy każda niepusta sekwencja znaków odstępu inna niż nowy wiersz jest zachowywana lub zastępowana przez jeden znak spacji, jest zdefiniowana w ramach implementacji.

Aby to zilustrować, jeśli przekażesz swój kod przez preprocesor, otrzymasz:

  int main()
  {
       i a = 10;
       return 0;

  }

Tak więc komentarze, podobnie jak spacje, służą do oddzielania tokenów.

Oznacza to, że kod będzie zawierał 14 tokenów, a nie 13.

Wynik będzie taki, jakbyś napisał:

i a = 10;

NIE:

ia = 10;

Zobacz tłumaczenie (inaczej kompilacja) Faza 3 , krok 2: „Każdy komentarz jest zastępowany jedną spacją” .

Tak więc, koncepcyjnie, i/*nt*/astaje się i aw tym momencie.

po prostu sprawdź, jaka jest forma twojego kodu

     int main()
    {
        int i/*nt*/a = 10;
        return 0;
    }

będzie mieć po wstępnym przetworzeniu. Po prostu dodaj flagę „-E” do swojego kompilatora, gcc -E myscript.c, a otrzymasz wynik:

e.sharaborin@landau:~$ gcc -E myscript.c
# 1 "myscript.c"
# 1 "<built-in>"
# 1 "<command-line>"
# 31 "<command-line>"
# 1 "/usr/include/stdc-predef.h" 1 3 4
# 32 "<command-line>" 2
# 1 "myscript.c"
int main()
{
    int i a = 10;
    return 0;
}

I oczywiście można wywnioskować, że jest błąd.

Tak, możesz to zrobić. Komentarze zostaną pominięte przez kompilator. Nie wpłyną one na zmienną. Będzie tak samo, tylko nie zapomnij zakończyć tagów komentarza.