„Int * nums = {5, 2, 1, 4}” powoduje błąd segmentacji

int *nums = {5, 2, 1, 4};
printf("%d\n", nums[0]);

powoduje segfault, podczas gdy

int nums[] = {5, 2, 1, 4};
printf("%d\n", nums[0]);

nie. Teraz:

int *nums = {5, 2, 1, 4};
printf("%d\n", nums);

wydruki 5.

Opierając się na tym, przypuszczałem, że notacja inicjalizacji tablicy {} ślepo ładuje te dane do dowolnej zmiennej po lewej stronie. Gdy jest to int [], tablica jest wypełniana zgodnie z potrzebami. Kiedy jest to int *, wskaźnik jest zapełniany przez 5, a lokalizacje pamięci po miejscu, w którym jest przechowywany wskaźnik, są wypełniane o 2, 1 i 4. So nums [0] próbuje usunąć 5, powodując segfault.

Jeśli się mylę, popraw mnie. A jeśli mam rację, proszę o wyjaśnienie, ponieważ nie rozumiem, dlaczego inicjatory tablic działają tak, jak działają.

W języku C istnieje (głupia) reguła mówiąca, że ​​każda zwykła zmienna może być zainicjowana listą inicjalizującą w nawiasach klamrowych, tak jakby była tablicą.

Na przykład możesz napisać int x = {0};, co jest całkowicie równoważne z int x = 0;.

Więc kiedy piszesz int *nums = {5, 2, 1, 4};, w rzeczywistości podajesz listę inicjalizującą pojedynczej zmiennej wskaźnikowej. Jednak jest to tylko jedna zmienna, więc zostanie przypisana tylko pierwsza wartość 5, reszta listy jest ignorowana (właściwie nie sądzę, aby kod z nadmiarem inicjalizatorów powinien się nawet kompilować za pomocą ścisłego kompilatora) - tak nie jest w ogóle zostać zapisane w pamięci. Kod jest równoważny z int *nums = 5;. Co oznacza, że numspowinien wskazywać na adres 5 .

W tym momencie powinieneś już otrzymać dwa ostrzeżenia / błędy kompilatora:

• Przypisywanie liczby całkowitej do wskaźnika bez rzutowania.
• Nadmiar elementów na liście inicjalizacyjnej.

A potem oczywiście kod ulegnie awarii i wypali się, ponieważ 5najprawdopodobniej nie jest to prawidłowy adres, do którego można się odwołać nums[0].

Na marginesie, powinieneś printfwskazać adresy ze %pspecyfikatorem lub w inny sposób wywołać niezdefiniowane zachowanie.

Nie jestem do końca pewien, co próbujesz tutaj zrobić, ale jeśli chcesz ustawić wskaźnik tak, aby wskazywał na tablicę, powinieneś zrobić:

int nums[] = {5, 2, 1, 4};
int* ptr = nums;

// or equivalent:
int* ptr = (int[]){5, 2, 1, 4};

Lub jeśli chcesz utworzyć tablicę wskaźników:

int* ptr[] = { /* whatever makes sense here */ };

EDYTOWAĆ

Po kilku badaniach mogę powiedzieć, że „lista inicjalizująca nadmiarowe elementy” rzeczywiście nie jest poprawna. C - jest to rozszerzenie GCC .

Standard 6.7.9 Inicjalizacja mówi (moje podkreślenie):

2 Żaden inicjator nie może próbować podać wartości dla obiektu nie zawartego w inicjowanej jednostce.

/ - /

11 Inicjator dla skalara powinien być pojedynczym wyrażeniem, opcjonalnie zamkniętym w nawiasy klamrowe. Początkową wartością obiektu jest wartość wyrażenia (po konwersji); obowiązują te same ograniczenia typu i konwersje, co w przypadku prostego przypisania, przyjmując typ skalara jako niekwalifikowaną wersję zadeklarowanego typu.

„Typ skalarny” jest standardowym terminem odnoszącym się do pojedynczych zmiennych, które nie są typu tablicowego, strukturalnego lub sumarycznego (są to nazywane „typami agregującymi”).

Tak więc w prostym języku angielskim standard mówi: „kiedy inicjalizujesz zmienną, możesz dodać kilka dodatkowych nawiasów klamrowych wokół wyrażenia inicjującego, tylko dlatego, że możesz”.

SCENARIUSZ 1

int *nums = {5, 2, 1, 4};    // <-- assign multiple values to a pointer variable
printf("%d\n", nums[0]);    // segfault

Dlaczego ten się rozbija?

Zadeklarowałeś numsjako wskaźnik do int - numsto ma zawierać adres one liczby całkowitej w pamięci.

Następnie próbowałeś zainicjować numstablicę wielu wartości. Tak więc bez zagłębiania się w wiele szczegółów jest to koncepcyjnie niepoprawne - nie ma sensu przypisywanie wielu wartości zmiennej, która ma mieć jedną wartość. Pod tym względem zobaczysz dokładnie ten sam efekt, jeśli zrobisz to:

int nums = {5, 2, 1, 4};    // <-- assign multiple values to an int variable
printf("%d\n", nums);    // also print 5

W każdym przypadku (przypisz wiele wartości do wskaźnika lub zmiennej int), wtedy zmienna otrzyma pierwszą wartość, która jest 5, a pozostałe wartości są ignorowane. Ten kod jest zgodny, ale otrzymasz ostrzeżenia dla każdej dodatkowej wartości, która nie powinna znajdować się w przypisaniu:

warning: excess elements in scalar initializer.

W przypadku przypisywania wielu wartości do zmiennej wskaźnikowej, program segfaults podczas uzyskiwania dostępu nums[0], co oznacza, że dosłownie odrzucasz wszystko, co jest zapisane pod adresem 5 . W tym przypadku nie przydzieliłeś żadnej prawidłowej pamięci dla wskaźnika nums.

Warto zauważyć, że nie ma segfaulta w przypadku przypisania wielu wartości do zmiennej int (nie wyłuskujemy tutaj żadnego nieprawidłowego wskaźnika).

SCENARIUSZ 2

int nums[] = {5, 2, 1, 4};

Ten nie powoduje segfaultów, ponieważ zgodnie z prawem przydzielasz tablicę 4 int w stosie.

SCENARIUSZ 3

int *nums = {5, 2, 1, 4};
printf("%d\n", nums);   // print 5

Ten nie działa zgodnie z oczekiwaniami, ponieważ drukujesz wartość samego wskaźnika - NIE tego, co wyłuskuje (co jest nieprawidłowym dostępem do pamięci).

Inni

Prawie zawsze jest skazane na segfault za każdym razem, gdy zakodujesz wartość takiego wskaźnika (ponieważ zadaniem systemu operacyjnego jest określenie, który proces może uzyskać dostęp do jakiej lokalizacji pamięci).

int *nums = 5;    // <-- segfault

Tak więc ogólną zasadą jest, aby zawsze inicjalizować wskaźnik do adresu jakiejś przydzielonej zmiennej, takiej jak:

int a;
int *nums = &a;

lub,

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

int *nums = {5, 2, 1, 4};jest źle sformułowanym kodem. Istnieje rozszerzenie GCC, które traktuje ten kod tak samo, jak:

int *nums = (int *)5;

próba utworzenia wskaźnika do adresu pamięci 5. (Nie wydaje mi się to przydatne rozszerzenie, ale wydaje mi się, że programiści tego chcą).

Aby uniknąć tego zachowania (lub przynajmniej otrzymać ostrzeżenie), możesz skompilować w trybie standardowym, np -std=c11 -pedantic .

Alternatywną formą prawidłowego kodu byłoby:

int *nums = (int[]){5, 2, 1, 4};

co wskazuje na zmienny literał o takim samym czasie przechowywania jak nums. Jednak int nums[]wersja jest ogólnie lepsza, ponieważ zajmuje mniej miejsca i można jej użyć sizeofdo wykrycia długości tablicy.

int *nums = {5, 2, 1, 4};

numsjest wskaźnikiem typu int. Więc powinieneś wskazać na jakąś prawidłową lokalizację pamięci.num[0]próbujesz wyłuskać jakąś losową lokalizację pamięci i stąd błąd segmentacji.

Tak, wskaźnik ma wartość 5 i próbujesz usunąć z niej odwołanie, co jest niezdefiniowanym zachowaniem w Twoim systemie. (Wygląda jak5 to, że nie jest to prawidłowa lokalizacja pamięci w twoim systemie)

Natomiast

int nums[] = {1,2,3,4};

jest prawidłową deklaracją, w której mówisz, że numsjest tablicą typu, inta pamięć jest przydzielana na podstawie liczby elementów przekazanych podczas inicjalizacji.

Przypisując {5, 2, 1, 4}

int *nums = {5, 2, 1, 4};

przypisujesz 5 do nums(po niejawnym rzutowaniu z int na wskaźnik do int). Po usunięciu wywołania wywołanie dostępu do lokalizacji pamięci pod adresem 0x5. To może nie być dozwolone dla twojego programu.

Próbować

printf("%p", (void *)nums);