Nieporozumienia dotyczące inicjalizacji macierzy w C

W języku C, jeśli zainicjuj tablicę w ten sposób:

int a[5] = {1,2};

wtedy wszystkie elementy tablicy, które nie zostały zainicjowane jawnie, zostaną zainicjowane niejawnie zerami.

Ale jeśli zainicjalizuję tablicę w ten sposób:

int a[5]={a[2]=1};

printf("%d %d %d %d %d\n", a[0], a[1],a[2], a[3], a[4]);

wynik:

1 0 1 0 0

Nie rozumiem, dlaczego a[0]drukuje 1zamiast 0? Czy jest to niezdefiniowane zachowanie?

Uwaga: to pytanie zostało zadane w wywiadzie.

TL; DR: Nie sądzę, że zachowanie int a[5]={a[2]=1};jest dobrze zdefiniowane, przynajmniej w C99.

Zabawne jest to, że jedynym bitem, który ma dla mnie sens, jest część, o którą pytasz: a[0]jest ustawiona na, 1ponieważ operator przypisania zwraca przypisaną wartość. To wszystko inne jest niejasne.

Gdyby był kod int a[5] = { [2] = 1 }, wszystko byłoby łatwe: to jest wyznaczone ustawienie inicjalizatora a[2]dla 1i wszystko inne do 0. Ale { a[2] = 1 }mamy niewyznaczony inicjator zawierający wyrażenie przypisania i wpadamy do króliczej nory.

Oto, co do tej pory znalazłem:

• a musi być zmienną lokalną.

  6.7.8 Inicjalizacja

  4. Wszystkie wyrażenia w inicjatorze dla obiektu, który ma statyczny czas trwania, powinny być wyrażeniami stałymi lub literałami łańcuchowymi.

  a[2] = 1nie jest wyrażeniem stałym, więc amusi mieć automatyczne przechowywanie.

• a jest objęty zakresem własnej inicjalizacji.

  6.2.1 Zakresy identyfikatorów

  7. Tagi struktury, unii i wyliczenia mają zakres, który zaczyna się tuż po pojawieniu się tagu w specyfikatorze typu, który deklaruje tag. Każda stała wyliczenia ma zakres, który zaczyna się zaraz po pojawieniu się jej definiującego modułu wyliczającego na liście modułów wyliczających. Każdy inny identyfikator ma zakres, który zaczyna się zaraz po zakończeniu jego deklaratora.

  Deklarator jest a[5], więc zmienne znajdują się w zakresie w ich własnej inicjalizacji.

• a żyje w swojej własnej inicjalizacji.

  6.2.4 Czas przechowywania obiektów

  4. Obiekt, którego identyfikator jest zadeklarowany bez powiązania i bez specyfikatora klasy pamięci,static ma automatyczny czas trwania .

  5. W przypadku takiego obiektu, który nie ma typu tablicy o zmiennej długości, jego czas życia rozciąga się od wejścia do bloku, z którym jest skojarzony, aż do zakończenia wykonywania tego bloku w jakikolwiek sposób. (Wprowadzenie bloku zamkniętego lub wywołanie funkcji wstrzymuje wykonanie bieżącego bloku, ale go nie kończy). Jeśli blok jest wprowadzany rekurencyjnie, za każdym razem tworzona jest nowa instancja obiektu. Początkowa wartość obiektu jest nieokreślona. Jeśli dla obiektu określono inicjalizację, jest ona wykonywana za każdym razem, gdy deklaracja zostanie osiągnięta podczas wykonywania bloku; w przeciwnym razie wartość staje się nieokreślona za każdym razem, gdy deklaracja zostanie osiągnięta.

• Następuje punkt sekwencji a[2]=1.

  6.8 Instrukcje i bloki

  4. Pełne wyrażenie jest wyrażeniem, które nie jest częścią innego wyrazu lub z declarator. Każde z poniższych jest pełnym wyrażeniem: inicjalizator ; wyrażenie w wyrażeniu wyrażenia; kontrolujące wyrażenie instrukcji wyboru ( iflub switch); kontrolne wyrażenie a whilelub doinstrukcja; każde z (opcjonalnych) wyrażeń forinstrukcji; (opcjonalne) wyrażenie w returninstrukcji. Koniec pełnego wyrażenia to punkt sekwencji.

  Należy pamiętać, że na przykład w int foo[] = { 1, 2, 3 }tej { 1, 2, 3 }części znajduje się lista zamkniętych klamra z inicjalizatorów, z których każdy ma temperaturę sekwencji po niej.

• Inicjalizacja jest wykonywana w kolejności na liście inicjatorów.

  6.7.8 Inicjalizacja

  17. Każda lista inicjatorów w nawiasach klamrowych ma skojarzony bieżący obiekt . Gdy nie ma żadnych oznaczeń, podobiekty bieżącego obiektu są inicjowane w kolejności zgodnej z typem bieżącego obiektu: elementy tablicy w rosnącej kolejności indeksów, elementy struktury w kolejności deklaracji i pierwszy nazwany element członkowski unii. […]

   

  19. Inicjalizacja powinna nastąpić w kolejności listy inicjalizatorów, przy czym każdy inicjator dostarczony dla określonego podobiektu przesłania każdy poprzednio wymieniony inicjator dla tego samego podobiektu; wszystkie podobiekty, które nie zostały zainicjowane jawnie, zostaną zainicjowane niejawnie w taki sam sposób, jak obiekty o statycznym czasie trwania.

• Jednak wyrażenia inicjatora niekoniecznie są oceniane w kolejności.

  6.7.8 Inicjalizacja

  23. Kolejność występowania efektów ubocznych w wyrażeniach listy inicjalizacji jest nieokreślona.

Jednak to wciąż pozostawia kilka pytań bez odpowiedzi:

• Czy punkty sekwencji są w ogóle istotne? Podstawowa zasada to:

  6.5 Wyrażenia

  2. Pomiędzy poprzednim a następnym punktem sekwencji obiekt będzie miał swoją przechowywaną wartość zmodyfikowaną co najwyżej raz przez ocenę wyrażenia . Ponadto poprzednia wartość jest tylko do odczytu w celu określenia wartości, która ma być przechowywana.

  a[2] = 1 jest wyrażeniem, ale inicjalizacja nie.

  Jest to nieco sprzeczne z załącznikiem J:

  J.2 Niezdefiniowane zachowanie

  • Pomiędzy dwoma punktami sekwencji obiekt jest modyfikowany więcej niż jeden raz lub jest modyfikowany i odczytywana jest poprzednia wartość, inaczej niż w celu określenia wartości do zapisania (6.5).

  Załącznik J mówi, że liczą się wszelkie modyfikacje, a nie tylko modyfikacje wyrażeniami. Biorąc jednak pod uwagę, że załączniki są nienormatywne, prawdopodobnie możemy to zignorować.

• W jaki sposób inicjalizacje podobiektów są sekwencjonowane w odniesieniu do wyrażeń inicjatora? Czy wszystkie inicjatory są oceniane jako pierwsze (w jakiejś kolejności), a następnie podobiekty są inicjowane z wynikami (w kolejności na liście inicjatorów)? Czy można je przeplatać?

Myślę, że int a[5] = { a[2] = 1 }jest wykonywany w następujący sposób:

1. Pamięć dla ajest przydzielana po wprowadzeniu zawierającego ją bloku. W tym momencie zawartość jest nieokreślona.
2. (Jedyny) inicjator jest wykonywany ( a[2] = 1), po którym następuje punkt sekwencji. Zapisuje 1w a[2]i powroty 1.
3. Który 1służy do zainicjowania a[0](pierwszy inicjator inicjuje pierwszy podobiekt).

Ale tu robi się rozmyty, ponieważ pozostałe elementy ( a[1], a[2], a[3], a[4]) mają być inicjowane 0, ale nie jest jasne, gdy: zdarza się, zanim a[2] = 1jest oceniany? Jeśli tak, a[2] = 1czy "wygra" i nadpisze a[2], ale czy to przypisanie będzie miało niezdefiniowane zachowanie, ponieważ nie ma punktu sekwencji między zerową inicjalizacją a wyrażeniem przypisania? Czy punkty sekwencji są w ogóle istotne (patrz wyżej)? A może zerowa inicjalizacja ma miejsce po ocenie wszystkich inicjatorów? Jeśli tak, a[2]powinno to skończyć 0.

Ponieważ standard C nie definiuje jasno, co się tutaj dzieje, uważam, że zachowanie jest nieokreślone (przez pominięcie).

Nie rozumiem, dlaczego a[0]drukuje 1zamiast 0?

Przypuszczalnie a[2]=1inicjalizuje się jako a[2]pierwsza, a wynik wyrażenia jest używany do inicjalizacji a[0].

Od N2176 (projekt C17):

6.7.9 Inicjalizacja

23. Oceny wyrażeń listy inicjalizacyjnej są sekwencjonowane w nieokreślony sposób względem siebie, a zatem kolejność, w jakiej występują jakiekolwiek skutki uboczne, jest nieokreślona. ¹⁵⁴⁾

Wydawałoby się więc, że produkcja 1 0 0 0 0również byłaby możliwa.

Wniosek: nie pisz inicjatorów, które modyfikują zainicjowaną zmienną w locie.

Myślę, że standard C11 obejmuje to zachowanie i mówi, że wynik jest nieokreślony i nie sądzę, aby C18 wprowadził jakiekolwiek istotne zmiany w tym obszarze.

Język standardowy nie jest łatwy do przeanalizowania. Odpowiednią sekcją normy jest §6.7.9 Inicjalizacja . Składnia jest udokumentowana jako:

initializer:
                assignment-expression
                { initializer-list }
                { initializer-list , }
initializer-list:
                designationopt initializer
                initializer-list , designationopt initializer
designation:
                designator-list =
designator-list:
                designator
                designator-list designator
designator:
                [ constant-expression ]
                . identifier

Zwróć uwagę, że jednym z terminów jest wyrażenie przypisania , a ponieważ a[2] = 1jest to niewątpliwie wyrażenie przypisania, jest dozwolone wewnątrz inicjatorów dla tablic o niestatycznym czasie trwania:

§4 Wszystkie wyrażenia w inicjatorze dla obiektu, który ma statyczny lub wątkowy czas trwania, powinny być wyrażeniami stałymi lub literałami łańcuchowymi.

Jednym z kluczowych akapitów jest:

§19 Inicjalizacja powinna odbywać się w kolejności listy inicjalizatorów, przy czym każdy inicjalizator przewidziany dla określonego podobiektu przesłania wszelkie poprzednio wymienione inicjatory dla tego samego podobiektu; ¹⁵¹⁾ wszystkie podobiekty, które nie zostały zainicjowane jawnie, zostaną zainicjowane niejawnie tak samo, jak obiekty o statycznym czasie trwania.

¹⁵¹⁾ Każdy inicjator dla podobiektu, który jest przesłonięty i nie jest używany do zainicjowania tego podobiektu, może w ogóle nie zostać oceniony.

Kolejny kluczowy akapit to:

§23 Oceny wyrażeń listy inicjalizacyjnej są nieokreślone względem siebie, a zatem kolejność, w jakiej występują jakiekolwiek skutki uboczne, jest nieokreślona. ¹⁵²⁾

¹⁵²⁾ W szczególności kolejność oceny nie musi być taka sama jak kolejność inicjalizacji podobiektu.

Jestem prawie pewien, że paragraf 23 wskazuje, że zapis w pytaniu:

int a[5] = { a[2] = 1 };

prowadzi do nieokreślonego zachowania. Przypisanie do a[2]jest efektem ubocznym, a kolejność oceny wyrażeń jest nieokreślona względem siebie. W związku z tym nie sądzę, aby można było odwołać się do standardu i twierdzić, że konkretny kompilator obsługuje to poprawnie lub nieprawidłowo.

My Understanding a[2]=1zwraca wartość 1 więc kod staje się

int a[5]={a[2]=1} --> int a[5]={1}

int a[5]={1}przypisz wartość dla [0] = 1

Stąd wypisuje 1 dla [0]

Na przykład

char str[10]={‘H’,‘a’,‘i’};


char str[0] = ‘H’;
char str[1] = ‘a’;
char str[2] = ‘i;

Na zagadkę staram się udzielić krótkiej i prostej odpowiedzi: int a[5] = { a[2] = 1 };

1. Pierwszy a[2] = 1jest ustawiony. Oznacza to, że tablica mówi:0 0 1 0 0
2. Ale oto, biorąc pod uwagę, że zrobiłeś to w { }nawiasach, które są używane do inicjalizacji tablicy w kolejności, przyjmuje pierwszą wartość (czyli 1) i ustawia ją na a[0]. To tak, jakby zostało int a[5] = { a[2] };tam, gdzie już dotarliśmy a[2] = 1. Wynikowa tablica to teraz:1 0 1 0 0

Inny przykład: int a[6] = { a[3] = 1, a[4] = 2, a[5] = 3 };- Mimo że kolejność jest nieco arbitralna, zakładając, że jest przesuwana od lewej do prawej, będzie przebiegać w tych 6 krokach:

0 0 0 1 0 0
1 0 0 1 0 0
1 0 0 1 2 0
1 2 0 1 2 0
1 2 0 1 2 3
1 2 3 1 2 3

Przypisanie a[2]= 1jest wyrażeniem, które ma wartość 1i zasadniczo zostało napisane int a[5]= { 1 };(z a[2]przypisanym efektem ubocznym 1).

Myślę, że int a[5]={ a[2]=1 };to dobry przykład dla programisty strzelającego sobie w stopę.

Mógłbym ulec pokusie, by pomyśleć, że chodziło Ci o to, int a[5]={ [2]=1 };że będzie to inicjator wyznaczony przez C99 ustawiający element 2 na 1, a resztę na zero.

W rzadkich przypadkach, o których naprawdę miałeś na myśli int a[5]={ 1 }; a[2]=1;, to byłby zabawny sposób pisania. W każdym razie do tego sprowadza się twój kod, mimo że niektórzy tutaj zauważyli, że nie jest dobrze zdefiniowany, kiedy zapis a[2]jest faktycznie wykonywany. Pułapka polega na tym, że a[2]=1nie jest to wyznaczony inicjator, ale proste przypisanie, które samo w sobie ma wartość 1.