Proste Typy Danych

Co to są proste typy danych?

Proste typy danych w C# to podstawowe typy, które służą do przechowywania danych takich jak liczby, znaki, wartości logiczne i inne. Każdy z tych typów zajmuje określoną ilość miejsca w pamięci i jest używany do różnych celów. Ważne jest, aby wybierać odpowiedni typ, zależnie od danych, które chcemy przechowywać.

Podział prostych typów danych:

Proste typy danych można podzielić na kilka kategorii:

• Liczby całkowite: np. int, short, long, byte
• Liczby zmiennoprzecinkowe: np. float, double, decimal
• Znaki: char
• Wartości logiczne: bool

Typy danych liczb całkowitych

Liczby całkowite to liczby bez części ułamkowej (np. -10, 0, 100). C# oferuje kilka typów do przechowywania liczb całkowitych:

byte

• Używany do przechowywania małych liczb całkowitych (tylko dodatnich).
• Zakres: od 0 do 255
• Zajmuje 1 bajt pamięci.

Przykład:

byte wiek = 15;
Console.WriteLine(wiek);  // Wypisze: 15

short

• Przechowuje mniejsze liczby całkowite.
• Zakres: od -32 768 do 32 767
• Zajmuje 2 bajty pamięci.

Przykład:

short liczba = 100;
Console.WriteLine(liczba);  // Wypisze: 100

int (ang. integer)

• Przechowuje liczby całkowite.
• Zakres: od -2 147 483 648 do 2 147 483 647
• Zajmuje 4 bajty pamięci.

Przykład:

int wiek = 25;
Console.WriteLine(wiek);  // Wypisze: 25

long

• Używany do przechowywania bardzo dużych liczb całkowitych.
• Zakres: od -9 223 372 036 854 775 808 do 9 223 372 036 854 775 807
• Zajmuje 8 bajtów pamięci.

Przykład:

long populacjaZiemi = 7800000000;
Console.WriteLine(populacjaZiemi);  // Wypisze: 7800000000

Typy danych zmiennoprzecinkowych

Liczby zmiennoprzecinkowe to liczby, które mogą mieć części ułamkowe (np. 3.14, -0.001). W C# dostępne są trzy typy do przechowywania liczb zmiennoprzecinkowych.

a) float

• Przechowuje liczby zmiennoprzecinkowe o pojedynczej precyzji.
• Zakres: od 1.5 × 10^−45 do 3.4 × 10^38
• Zajmuje 4 bajty pamięci.
• Wartości float kończą się literą f.

Przykład:

float temperatura = 36.6f;
Console.WriteLine(temperatura);  // Wypisze: 36.6

double

• Przechowuje liczby zmiennoprzecinkowe o podwójnej precyzji (najczęściej używany).
• Zakres: od 5.0 × 10^−324 do 1.7 × 10^308
• Zajmuje 8 bajtów pamięci.

Przykład:

double odleglosc = 149.6;
Console.WriteLine(odleglosc);  // Wypisze: 149.6

decimal

• Używany do przechowywania liczb zmiennoprzecinkowych o bardzo wysokiej precyzji, np. w obliczeniach finansowych.
• Zakres: od ±1.0 × 10^−28 do ±7.9 × 10^28
• Zajmuje 16 bajtów pamięci.
• Wartości decimal kończą się literą m.

Przykład:

decimal cena = 99.99m;
Console.WriteLine(cena);  // Wypisze: 99.99

Typ danych znakowy – char

Typ char przechowuje pojedyncze znaki – np. litery, cyfry, symbole. Znak jest zawsze ujęty w pojedynczy cudzysłów.

• Zakres: od ’\u0000′ (0) do ’\uffff’ (65 535), czyli każdy znak w kodzie Unicode.
• Zajmuje 2 bajty pamięci.

Przykład:

char znak = 'A';
Console.WriteLine(znak);  // Wypisze: A

Typ danych tekstowy – string

Typ string przechowuje ciąg znaków, czyli tekst (np. słowa, zdania). Jest to zbiór wielu znaków char, zapisany w podwójnym cudzysłowie.

• string jest zmienną referencyjną, ale uznawany jest za prosty typ danych w codziennym użyciu.

Przykład:

string imie = "Jan";
Console.WriteLine(imie);  // Wypisze: Jan

Typ danych logiczny – bool

Typ bool przechowuje tylko dwie możliwe wartości: true (prawda) lub false (fałsz). Jest on używany w instrukcjach warunkowych i logice programów.

• Zajmuje 1 bajt pamięci.

Przykład:

bool czyPadaDeszcz = true;
Console.WriteLine(czyPadaDeszcz);  // Wypisze: True

Podsumowanie prostych typów danych w C#:

Typy bezznakowe (unsigned)

Typy bezznakowe to typy, które mogą przechowywać tylko liczby dodatnie. Dzięki temu mogą przechowywać większe liczby w tym samym zakresie pamięci, ponieważ nie muszą rezerwować miejsca na liczby ujemne.

uint (ang. unsigned integer)

• Przechowuje tylko liczby całkowite dodatnie.
• Zakres: od 0 do 4 294 967 295
• Zajmuje 4 bajty pamięci.

Przykład:

uint liczba = 4000000000;
Console.WriteLine(liczba);  // Wypisze: 4000000000

W przeciwieństwie do typu int, który ma zakres od -2 miliardów do 2 miliardów, typ uint przechowuje tylko liczby dodatnie i może przechowywać wartości aż do 4 miliardów.

ushort (ang. unsigned short)

• Przechowuje tylko liczby całkowite dodatnie.
• Zakres: od 0 do 65 535
• Zajmuje 2 bajty pamięci.

Przykład:

ushort małaLiczba = 60000;
Console.WriteLine(małaLiczba);  // Wypisze: 60000

ulong (ang. unsigned long)

• Przechowuje tylko liczby całkowite dodatnie.
• Zakres: od 0 do 18 446 744 073 709 551 615
• Zajmuje 8 bajtów pamięci.

Przykład:

ulong bardzoDużaLiczba = 18000000000000000000;
Console.WriteLine(bardzoDużaLiczba);  // Wypisze: 18000000000000000000

Podsumowanie typów bezznakowych:

Typy bezznakowe pozwalają na przechowywanie większych liczb dodatnich w tej samej ilości pamięci, co ich odpowiedniki znakowe.

Kiedy używać typów bezznakowych?

Typy bezznakowe używamy, gdy wiemy, że przechowywane liczby będą zawsze dodatnie. Dzięki temu możemy przechowywać większy zakres liczb w tej samej ilości pamięci.