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

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 danychZakres wartośćiRozmiar (w bajtach)OpisPrzykład wartości
int-2 147 483 648 do 2 147 483 6474Liczby całkowite123, -45
short-32 768 do 32 7672Małe liczby całkowite100, -100
long-9 223 372 036 854 775 808 do 9 223 372 036 854 775 8078Bardzo duże liczby całkowite10000000000
byte0 do 2551Małe liczby całkowite (tylko dodatnie)255, 0
float±1.5 × 10^−45 do ±3.4 × 10^384Liczby zmiennoprzecinkowe (niskiej precyzji)3.14f
double±5.0 × 10^−324 do ±1.7 × 10^3088Liczby zmiennoprzecinkowe (wysokiej precyzji)3.14159
decimal±1.0 × 10^−28 do ±7.9 × 10^2816Bardzo dokładne liczby zmiennoprzecinkowe (używane w finansach)99.99m
charPojedynczy znak (np. 'A’, '1′)2Pojedyncze znaki Unicode’A’, '1′, ’!’
stringCiąg znaków (np. „Ala ma kota”)ZmiennyPrzechowuje tekst„Cześć”, „Jan”
booltrue lub false1Przechowuje 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 danychZakres wartościRozmiar (w bajtach)OpisPrzykład wartości
uint0 do 4 294 967 2954Bezznakowy typ liczby całkowitej4000000000
ushort0 do 65 5352Bezznakowy typ małej liczby całkowitej60000
ulong0 do 18 446 744 073 709 551 6158Bezznakowy typ bardzo dużej liczby całkowitej18000000000000000000
byte0 do 2551Bezznakowy typ małej liczby całkowitej200

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.