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
Konwertowanie liter na kody ASCII i odwrotnie
Każdy znak w C# (i w ogóle w informatyce) jest reprezentowany przez wartość numeryczną zgodną z kodowaniem ASCII lub Unicode. Możemy więc konwertować znaki na ich kody numeryczne i odwrotnie.
Konwersja znaku na kod ASCII
- Przykład:
char znak = 'A';
int kodAscii = (int)znak;
Console.WriteLine($"Kod ASCII znaku '{znak}' to {kodAscii}.");
//Wynik
//Kod ASCII znaku 'A' to 65.
Konwersja kodu ASCII na znak
- Przykład:
int kodAscii = 66;
char znak = (char)kodAscii;
Console.WriteLine($"Znak o kodzie ASCII {kodAscii} to '{znak}'.");
//Wynik
//Znak o kodzie ASCII 66 to 'B'.
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#:
Typ danych | Zakres wartośći | Rozmiar (w bajtach) | Opis | Przykład wartości |
---|---|---|---|---|
int | -2 147 483 648 do 2 147 483 647 | 4 | Liczby całkowite | 123, -45 |
short | -32 768 do 32 767 | 2 | Małe liczby całkowite | 100, -100 |
long | -9 223 372 036 854 775 808 do 9 223 372 036 854 775 807 | 8 | Bardzo duże liczby całkowite | 10000000000 |
byte | 0 do 255 | 1 | Małe liczby całkowite (tylko dodatnie) | 255, 0 |
float | ±1.5 × 10^−45 do ±3.4 × 10^38 | 4 | Liczby zmiennoprzecinkowe (niskiej precyzji) | 3.14f |
double | ±5.0 × 10^−324 do ±1.7 × 10^308 | 8 | Liczby zmiennoprzecinkowe (wysokiej precyzji) | 3.14159 |
decimal | ±1.0 × 10^−28 do ±7.9 × 10^28 | 16 | Bardzo dokładne liczby zmiennoprzecinkowe (używane w finansach) | 99.99m |
char | Pojedynczy znak (np. 'A’, '1′) | 2 | Pojedyncze znaki Unicode | ’A’, '1′, ’!’ |
string | Ciąg znaków (np. „Ala ma kota”) | Zmienny | Przechowuje tekst | „Cześć”, „Jan” |
bool | true lub false | 1 | Przechowuje wartość logiczną | true, false |
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.
Typ danych | Zakres wartości | Rozmiar (w bajtach) | Opis | Przykład wartości |
---|---|---|---|---|
uint | 0 do 4 294 967 295 | 4 | Bezznakowy typ liczby całkowitej | 4000000000 |
ushort | 0 do 65 535 | 2 | Bezznakowy typ małej liczby całkowitej | 60000 |
ulong | 0 do 18 446 744 073 709 551 615 | 8 | Bezznakowy typ bardzo dużej liczby całkowitej | 18000000000000000000 |
byte | 0 do 255 | 1 | Bezznakowy typ małej liczby całkowitej | 200 |
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.