Phenquestions
Zrozumienie Sizeof:
Zanim zagłębimy się w dyskusję o rozmiarze operatora, najpierw zrozumiemy znaczenie operatora. Operator jest reprezentowany przez token lub symbol, który służy do wykonywania operacji, takich jak dodawanie, odejmowanie, mnożenie, dzielenie itp. na wartościach lub zmiennych (Operandy). Na przykład „*” jest symbolem używanym do reprezentowania operacji mnożenia i działa na dwóch operandach (wynik = a * b ;). To jest przykład operatora binarnego.
Jeśli jednak operator działa tylko na jednym operandzie, nazywamy go operatorem jednoargumentowym. Operator sizeof jest jednym z jednoargumentowych operatorów, które istnieją w języku programowania C i najwyraźniej operuje tylko na jednym operandzie. Operator sizeof zwraca rozmiar operandu. Oznacza to, że z wartości zwracanej przez operatora Sizeof możemy jasno określić, ile bajtów przydzielono do przechowywania danego operandu w pamięci komputera.
Pamięć komputera to zbiór jednostek pamięci (i.mi. bajt). Gdy sizeof (int) zwraca cztery w konkretnym systemie komputerowym, możemy powiedzieć, że zmienna całkowita zajmuje 4 bajty, aby przechowywać swoją wartość w pamięci tego konkretnego systemu komputerowego. Należy również pamiętać, że zwracana wartość operatora sizeof zależy również od używanych maszyn (system 32-bitowy lub system 64-bitowy).
Składnia:
Rozmiar(typ)Rozmiar (wyrażenie)
Zwracany typ sizeof to size_t.
Przykłady:
Teraz, gdy rozumiemy operator sizeof i znamy składnię, przyjrzyjmy się kilku przykładom, które pomogą nam lepiej zrozumieć koncepcję.
- Sizeof dla typów wbudowanych (przykład 1.do)
- Rozmiar dla tablicy (przykład 2.do)
- Sizeof dla typów zdefiniowanych przez użytkownika (przykład3.do)
- Sizeof dla zmiennych (przykład4.do)
- Sizeof dla wyrażenia (przykład5.do)
- Praktyczne wykorzystanie sizeof (przykład6.do)
Sizeof dla typów wbudowanych (przykład 1.do):
W tym programie zobaczymy jak działa operator sizeof dla wbudowanych typów danych takich jak int, char, float, double. Spójrzmy na program i wyjście.
#zawieraćint main()
printf("Rozmiar znaku = %ld \n", sizeof(znak));
printf("Rozmiar int = %ld \n", sizeof(int));
printf("Rozmiar float = %ld \n", sizeof(float));
printf("Rozmiar double = %ld \n\n", sizeof(double));
printf("Rozmiar short int = %ld \n", sizeof(short int));
printf("Rozmiar long int = %ld \n", sizeof(long int));
printf("Rozmiar long long int = %ld \n", sizeof(long long int));
printf("Rozmiar long double = %ld \n", sizeof(long double));
zwróć 0;
Rozmiar dla tablicy (przykład 2.do)
W tym programie zobaczymy, jak używać operatora sizeof dla różnych typów tablic. W przypadku tablicy zwróci operator sizeof (Nie. elementów w tablicy * Sizeof (typ tablicy)). Na przykład, gdy deklarujemy tablicę typu integer składającą się z 10 elementów (int SmartPhones [10] ;), sizeof(Smartphones) zwróci:
(Nie. elementów w smartfonach * sizeof(int)) = (10 * 4) = 40Spójrzmy na program i wyjście.
#zawieraćint main()
int smartfony[10];
char SmartPhoneNames[10];
podwójna cena smartfonów[10];
printf("Rozmiar int = %ld \n", sizeof(int));
printf("Rozmiar znaku = %ld \n", sizeof(znak));
printf("Rozmiar double = %ld \n", sizeof(double));
/* Sprawdź rozmiar tablicy*/
printf("Rozmiar smartfonów[10] = %ld \n", sizeof(smartfony));
printf("Rozmiar SmartPhoneNames[10] = %ld \n", sizeof(SmartPhoneNames));
printf("Rozmiar Ceny Smartfonów[10] = %ld \n", sizeof(Cena Smartfonów));
zwróć 0;
Sizeof dla typów zdefiniowanych przez użytkownika (przykład 3.do):
W tym przykładzie zobaczymy, jak używać operatora sizeof dla typów danych zdefiniowanych przez użytkownika, takich jak structure i union. Użyjmy programu i zrozummy wynik.
Teraz, patrząc na program, możemy ręcznie obliczyć rozmiar SmartPhoneType. Jak widać poniżej, SmartPhoneType jest strukturą i zawiera następujące elementy:
- Liczba zmiennej typu znaku = 1 [sp_name]
- Liczba zmiennej typu integer = 1 [sp_version]
- Liczba zmiennych typu float= 3 [sp_length, sp_width, sp_height]
Z przykładu-1 widzieliśmy, że:
-
- Rozmiar znaku to 1 bajt
- Wielkość liczby całkowitej to 4 bajty
- Rozmiar pływaka to 4 bajty
Dlatego jeśli zsumujemy wielkość wszystkich elementów w konstrukcji, powinniśmy być w stanie uzyskać wielkość konstrukcji, ja.mi. Typ smartfona. Dlatego rozmiar struktury powinien wynosić = (1 + 4 + 4 + 4 + 4) bajtów = 17 bajtów. Jednak dane wyjściowe programu mówią, że rozmiar struktury to 20. Dodatkowe 3 bajty (sp_name, który jest znakiem, zajmuje 4 bajty zamiast 1 bajtu) przydzielone dla struktury ze względu na dopełnienie struktury.
#zawierać/* Utwórz zdefiniowany przez użytkownika typ struktury - SmartPhoneType*/
struct SmartPhoneType
znak nazwa_sp;
int sp_wersja;
zmiennoprzecinkowa długość_sp;
zmiennoprzecinkowa szerokość_sp;
pływak sp_wysokość;
Smartfon;
/* Zdefiniuj typ unii zdefiniowany przez użytkownika - SmartPhoneUnionType*/
Union SmartPhoneTyp Unii
znak nazwa_sp;
int sp_wersja;
zmiennoprzecinkowa długość_sp;
zmiennoprzecinkowa szerokość_sp;
pływak sp_wysokość;
Smartfon_u;
int main()
/* Sprawdź rozmiar struktury i unii*/
printf("Rozmiar struktury = %ld \n", sizeof(SmartPhone));
printf("Rozmiar unii = %ld \n", sizeof(SmartPhone_u));
zwróć 0;
Sizeof dla zmiennych (przykład4.do):
Ten przykładowy program ilustruje, że operator sizeof jest w stanie zaakceptować zmienną również i zwrócić jej rozmiar.
#zawieraćint main()
/* Zadeklaruj zmienną i tablicę typu char, int, float i double */
znak zm_a, zm_b[20];
int zm_c, zm_d[20];
float zm_e, zm_f[20];
podwójna var_g, var_h[20];
/* Sprawdź rozmiar zmiennych i tablicy.
Ten program pokazuje, że zmienna może również
być użyty jako operand sizeofoperatora*/
/* rozmiar znaku, zmiennej char i tablicy znaków*/
printf("Rozmiar znaku = %ld \n", sizeof(znak));
printf("Rozmiar var_a = %ld \n", sizeof(var_a));
printf("Rozmiar var_b[20] = %ld \n\n", sizeof(var_b));
/* rozmiar int, zmiennej int i tablicy int*/
printf("Rozmiar int = %ld \n", sizeof(int));
printf("Rozmiar var_c = %ld \n", sizeof(var_c));
printf("Rozmiar var_d[20] = %ld \n\n", sizeof(var_d));
/* rozmiar float, zmiennej float i tablicy float*/
printf("Rozmiar float = %ld \n", sizeof(float));
printf("Rozmiar var_e = %ld \n", sizeof(var_e));
printf("Rozmiar var_f[20] = %ld \n\n", sizeof(var_f));
/* rozmiar podwójnej, podwójnej zmiennej i podwójnej tablicy*/
printf("Rozmiar double = %ld \n", sizeof(double));
printf("Rozmiar var_g = %ld \n", sizeof(var_g));
printf("Rozmiar var_h[20] = %ld \n", sizeof(var_h));
zwróć 0;
Sizeof dla wyrażenia(przykład5.do):
W tym przykładowym programie pokażemy, że operator sizeof może również akceptować wyrażenie i zwracać rozmiar wynikowego wyrażenia the.
#zawieraćint main()
int zm_a = 5, zm_b = 3;
podwójna var_c = 2.5, zm_d = 4.5;
printf("Rozmiar int = %ld \n", sizeof(int));
printf("Rozmiar double = %ld \n\n", sizeof(double));
printf("Rozmiar var_a * var_b = %ld \n", sizeof(var_a * var_b));
printf("Rozmiar var_c * var_d = %ld \n", sizeof(var_c * var_d));
/* Tu mnożymy zmienną całkowitą przez zmienną double.
Dlatego operator sizeof zwróci rozmiar maksymalnego rozmiaru
zmienna i.mi. podwójna zmienna typu.*/
printf("Rozmiar var_a * var_c = %ld \n", sizeof(var_a * var_c));
zwróć 0;
Praktyczne wykorzystanie sizeof (przykład6.do):
Ten przykładowy program pomoże Ci zrozumieć praktyczny przypadek użycia operatora sizeof. Operator Sizeof jest bardzo przydatny podczas przydzielania pamięci dynamicznej ze sterty za pomocą malloc. Spójrzmy na program i wyjście.
#zawierać#zawierać
struktura typedef
znak nazwa_sp;
int sp_wersja;
zmiennoprzecinkowa długość_sp;
zmiennoprzecinkowa szerokość_sp;
pływak sp_wysokość;
Typ smartfona;
int main()
/* Przydziel pamięć w pamięci sterty do przechowywania pięciu SmartPhoneType
zmienne.
*/
SmartPhoneType * SmartPhone_Ptr = (SmartPhoneType *)malloc(5 * sizeof(SmartPhoneType));
jeśli (SmartPhone_Ptr != NULL)
printf("Pamięć przydzielona dla 5 zmiennych struktury SmartPhoneType w
pamięć sterty.\n");
jeszcze
printf("Wystąpił błąd podczas alokacji pamięci sterty!”);
zwróć 0;
Wniosek:
Sizeof jest ważnym operatorem jednoargumentowym w języku programowania C. Pomaga nam w określeniu rozmiaru prymitywnych typów danych, typów danych zdefiniowanych przez użytkownika, wyrażeń itp. w pamięci komputera. Operator Sizeof odgrywa ważną rolę w przydzielaniu pamięci dynamicznej w C za pomocą malloc, calloc itp. w pamięci sterty.
