Jeśli liczba jest zbyt duża, czy przenosi się do następnej lokalizacji w pamięci?

Przeglądałem programowanie w C i przeszkadza mi tylko kilka rzeczy.

Weźmy na przykład ten kod:

int myArray[5] = {1, 2, 2147483648, 4, 5};
int* ptr = myArray;
int i;
for(i=0; i<5; i++, ptr++)
    printf("\n Element %d holds %d at address %p", i, myArray[i], ptr);

Wiem, że int może pomieścić maksymalną wartość dodatnią 2 147 483 647. A zatem, przechodząc o jeden powyżej, „rozlewa się” na następny adres pamięci, co powoduje, że element 2 pojawia się pod tym adresem jako „-2147483648”? Ale to naprawdę nie ma sensu, ponieważ na wyjściu nadal jest napisane, że następny adres zawiera wartość 4, a następnie 5. Jeśli liczba przelałaby się na następny adres, to nie zmieniłoby to wartości zapisanej pod tym adresem ?

Nie pamiętam z programowania w MIPS Assembly i patrzenia, jak adresy zmieniają się podczas programu krok po kroku, że wartości przypisane do tych adresów zmieniają się.

O ile nie pamiętam niepoprawnie, oto kolejne pytanie: Jeśli liczba przypisana do określonego adresu jest większa niż typ (jak w myArray [2]), to czy nie wpływa to na wartości przechowywane pod kolejnym adresem?

Przykład: Mamy int myNum = 4 miliardy pod adresem 0x10010000. Oczywiście myNum nie może przechowywać 4 miliardów, więc pojawia się jako pewna liczba ujemna pod tym adresem. Mimo że nie jest w stanie zapisać tak dużej liczby, nie ma to wpływu na wartość przechowywaną pod kolejnym adresem 0x10010004. Poprawny?

Adresy pamięci mają po prostu wystarczającą ilość miejsca, aby pomieścić pewne rozmiary liczb / znaków, a jeśli rozmiar przekroczy limit, wówczas będzie reprezentowany inaczej (jak próba zapisania 4 miliardów w int, ale pojawi się jako liczba ujemna) i więc nie ma to wpływu na liczby / znaki przechowywane pod następnym adresem.

Przepraszam, jeśli poszedłem za burtę. Cały dzień miałem od tego pierdnięcie mózgu.

Nie. W C zmienne mają ustalony zestaw adresów pamięci do pracy. Jeśli pracujesz w systemie z 4 bajtami intsi ustawisz intzmienną na, 2,147,483,647a następnie dodasz 1, zmienna zwykle będzie zawierać -2147483648. (W większości systemów. Zachowanie jest w rzeczywistości niezdefiniowane.) Żadne inne lokalizacje pamięci nie zostaną zmodyfikowane.

Zasadniczo kompilator nie pozwoli ci przypisać wartości, która jest zbyt duża dla tego typu. To wygeneruje błąd kompilatora. Jeśli wymusisz to w przypadku, wartość zostanie obcięta.

Patrząc nieco bitowo, jeśli typ może przechowywać tylko 8 bitów i spróbujesz zmusić wartość 1010101010101do niego za pomocą skrzynki, skończysz z dolnymi 8 bitami lub 01010101.

W twoim przykładzie, niezależnie od tego, co zrobisz myArray[2], myArray[3]będzie zawierać „4”. Nie ma „przelewu”. Próbujesz umieścić coś, co ma więcej niż 4 bajty, po prostu odetnie wszystko z wyższej półki, pozostawiając dolne 4 bajty. W większości systemów spowoduje to -2147483648.

Z praktycznego punktu widzenia chcesz po prostu upewnić się, że tak się nigdy nie stanie. Tego rodzaju przepełnienia często powodują trudne do rozwiązania wady. Innymi słowy, jeśli uważasz, że istnieje jakakolwiek szansa, że ​​twoje wartości będą w miliardach, nie używaj int.

Przepełnienie całkowitą ze znakiem jest zachowaniem niezdefiniowanym. Jeśli tak się stanie, twój program jest nieprawidłowy. Kompilator nie musi tego sprawdzać, więc może wygenerować plik wykonywalny, który wydaje się robić coś rozsądnego, ale nie ma gwarancji, że to zrobi.

Jednak przepełnienie liczb całkowitych bez znaku jest dobrze zdefiniowane. To zawinie modulo UINT_MAX + 1. Nie wpłynie to na pamięć nie zajmowaną przez zmienną.

Zobacz także https://stackoverflow.com/q/18195715/951890

Istnieją więc dwie rzeczy:

• poziom języka: jakie są semantyki języka C
• poziom maszyny: jaka jest semantyka zestawu / procesora, którego używasz

Na poziomie językowym:

W C:

• przepełnienie i niedopełnienie są zdefiniowane jako arytmetyka modulo dla liczb całkowitych bez znaku , a zatem ich wartość „pętle”
• przepełnienie i niedopełnienie są niezdefiniowanymi zachowaniami dla podpisanych liczb całkowitych, więc wszystko może się zdarzyć

Dla tych, którzy chcieliby przykładu „cokolwiek”, widziałem:

for (int i = 0; i >= 0; i++) {
    ...
}

zmienić się w:

for (int i = 0; true; i++) {
    ...
}

i tak, jest to uzasadniona transformacja.

Oznacza to, że rzeczywiście istnieje potencjalne ryzyko zastąpienia pamięci przy przepełnieniu z powodu dziwnej transformacji kompilatora.

Uwaga: na Clang lub gcc użyj -fsanitize=undefinedw Debugowaniu, aby aktywować narzędzie do dezynfekcji niezdefiniowanych zachowań, które przerwie działanie przy niedopełnieniu / przepełnieniu podpisanych liczb całkowitych.

Lub oznacza to, że można zastąpić pamięć, używając wyniku operacji do indeksowania (niezaznaczonego) do tablicy. Jest to niestety o wiele bardziej prawdopodobne w przypadku braku wykrywania niedopełnienia / przepełnienia.

Uwaga: na Clang lub gcc użyj -fsanitize=addressw Debugowaniu, aby aktywować narzędzie Sanitizer adresu, które przerwie dostęp poza granicami.

Na poziomie maszyny :

To zależy od instrukcji montażu i używanego procesora:

• na x86 ADD użyje 2-dopełniacza przy przepełnieniu / niedopełnieniu i ustawi OF (flaga przepełnienia)
• w przyszłym procesorze Mill będą dostępne 4 różne tryby przepełnienia dla Add:
  • Modulo: moduł 2 uzupełnień
  • Pułapka: pułapka jest generowana, zatrzymując obliczenia
  • Nasycenie: wartość utknie do wartości minimalnej przy przepełnieniu lub maksimum przy przepełnieniu
  • Podwójna szerokość: wynik jest generowany w rejestrze o podwójnej szerokości

Zauważ, że niezależnie od tego, czy coś dzieje się w rejestrach, czy w pamięci, w żadnym przypadku procesor nie zastępuje pamięci po przepełnieniu.

Aby udzielić odpowiedzi @ StevenBurnap, dzieje się tak z powodu sposobu działania komputerów na poziomie komputera.

Twoja tablica jest przechowywana w pamięci (np. W pamięci RAM). Gdy wykonywana jest operacja arytmetyczna, wartość z pamięci jest kopiowana do rejestrów wejściowych obwodu, który wykonuje arytmetykę (ALU: Arithmetic Logic Unit ), następnie operacja jest wykonywana na danych w rejestrach wejściowych, co daje wynik w rejestrze wyjściowym. Wynik ten jest następnie kopiowany z powrotem do pamięci pod prawidłowym adresem w pamięci, pozostawiając pozostałe obszary pamięci nietknięte.

Po pierwsze (zakładając standard C99), możesz chcieć dołączyć <stdint.h>standardowy nagłówek i użyć niektórych typów tam zdefiniowanych, w szczególności, int32_tktóra jest dokładnie 32-bitową liczbą całkowitą ze uint64_tznakiem lub dokładnie dokładnie 64-bitową liczbą całkowitą bez znaku i tak dalej. Możesz chcieć używać typów takich jak int_fast16_tze względu na wydajność.

Przeczytaj inne odpowiedzi wyjaśniające, że arytmetyka bez znaku nigdy nie rozlewa (ani nie przepełnia) do sąsiednich miejsc pamięci. Uważaj na niezdefiniowane zachowanie przy podpisanym przepełnieniu.

Następnie, jeśli chcesz obliczyć dokładnie ogromne liczby całkowite (np. Chcesz obliczyć silnię 1000 ze wszystkimi 2568 cyframi dziesiętnymi), potrzebujesz bigintów, czyli dowolnych liczb precyzji (lub bignów). Algorytmy efektywnej arytmetyki bigint są bardzo sprytne i zwykle wymagają użycia specjalistycznych instrukcji maszynowych (np. Niektóre dodają słowo z przeniesieniem, jeśli procesor to posiada). Dlatego zdecydowanie zalecam w takim przypadku użycie istniejącej biblioteki bigint, takiej jak GMPlib