Zmienne C # i (prymitywne) typy danych

W tym samouczku dowiemy się o zmiennych, tworzeniu zmiennych w C # i różnych typach danych obsługiwanych przez język programowania C #.

Zmienna to symboliczna nazwa nadana komórce pamięci. Zmienne służą do przechowywania danych w programie komputerowym.

Jak zadeklarować zmienne w C #?

Oto przykład deklarowania zmiennej w C #.

 int wiek;

W tym przykładzie zadeklarowano zmienną age typu int(liczba całkowita), która może przechowywać tylko wartości całkowite.

Wartość zmiennej możemy przypisać później w naszym programie w następujący sposób:

 int wiek;……… wiek = 24;

Jednak zmienna może również zostać zainicjowana do jakiejś wartości podczas deklaracji. Na przykład,

 int wiek = 24;

Tutaj zmienna wiek typu intjest deklarowana i inicjowana 24w tym samym czasie.

Ponieważ jest to zmienna, możemy również zmienić wartość zmiennych. Na przykład,

int wiek = 24; wiek = 35;

Tutaj wartość wieku zostaje zmieniona na 35 z 24.

Zmienne w C # muszą zostać zadeklarowane, zanim będą mogły być używane. Oznacza to, że nazwa i typ zmiennej muszą być znane, zanim będzie można przypisać im wartość. Właśnie dlatego C # jest nazywany językiem z typowaniem statycznym.

Po zadeklarowaniu typu danych zmiennej nie można zmienić w zakresie. Zakres można traktować jako blok kodu, w którym zmienna jest widoczna lub dostępna do użycia. Jeśli nie rozumiesz poprzedniego stwierdzenia, nie martw się, o zakresach dowiemy się w kolejnych rozdziałach.

Na razie pamiętaj, że w C # nie możemy wykonać następujących czynności:

int wiek; wiek = 24;……… wiek zmiennoprzecinkowy;

Zmienne niejawnie wpisane

Alternatywnie w C # możemy zadeklarować zmienną bez znajomości jej typu za pomocą varsłowa kluczowego. Takie zmienne nazywane są zmiennymi lokalnymi o niejawnym typie .

Zmienne zadeklarowane przy użyciu varsłowa kluczowego muszą zostać zainicjowane w momencie deklaracji.

 wartość var ​​= 5;

Kompilator określa typ zmiennej na podstawie wartości przypisanej do zmiennej. W powyższym przykładzie value jest typu int. Jest to równoważne z:

wartość int; wartość = 5;

Możesz dowiedzieć się więcej o niejawnie wpisanych zmiennych lokalnych.

Zasady nazewnictwa zmiennych w języku C #

Istnieją pewne zasady, których musimy przestrzegać podczas nazywania zmiennej. Zasady nazywania zmiennej w C # to:

  1. Nazwa zmiennej może zawierać tylko litery (duże i małe), podkreślenie (_) i cyfry.
  2. Nazwa zmiennej musi zaczynać się od litery, podkreślenia lub symbolu @. Na przykład reguły nazewnictwa zmiennych w języku C #
    Nazwy zmiennych Uwagi
    Nazwa Ważny
    temat101 Ważny
    _wiek Prawidłowe (sprawdzona metoda nazywania prywatnych zmiennych składowych)
    @przerwa Prawidłowe (używane, jeśli nazwa jest zastrzeżonym słowem kluczowym)
    101 z zastrzeżeniem Nieprawidłowe (zaczyna się od cyfry)
    Twoje imię Ważny
    Twoje imię Nieprawidłowe (zawiera spacje)
  3. C # rozróżnia wielkość liter. Oznacza to, że wiek i wiek odnoszą się do 2 różnych zmiennych.
  4. Nazwa zmiennej nie może być słowem kluczowym C #. Na przykład if, for, usingnie może być nazwą zmiennej. Będziemy omawiać więcej słów kluczowych C # w następnym samouczku.

Sprawdzone metody nazywania zmiennej

  1. Wybierz nazwę zmiennej, która ma sens. Na przykład imię, wiek, temat ma więcej sensu niż n, a i s.
  2. Użyj notacji camelCase (zaczyna się od małej litery) do nazwania zmiennych lokalnych. Na przykład numberOfStudents, wiek itp.
  3. Użyj PascalCase lub CamelCase (zaczyna się wielką literą) do nazwania publicznych zmiennych składowych. Na przykład imię, cena itp.
  4. Użyj początkowego podkreślenia (_), po którym następuje notacja camelCase, aby nazwać prywatne zmienne składowe. Na przykład _bankBalance, _emailAddress itp.

Możesz dowiedzieć się więcej o konwencjach nazewnictwa w C # tutaj.

Nie martw się o zmienne składowe publiczne i prywatne. Dowiemy się o nich w dalszych rozdziałach.

Prymitywne typy danych języka C #

Zmienne w C # są ogólnie podzielone na dwa typy: typy wartości i typy odwołań . W tym samouczku omówimy prymitywne (proste) typy danych, które są podklasą typów wartości.

Typy referencyjne zostaną omówione w późniejszych samouczkach. Jeśli jednak chcesz dowiedzieć się więcej o typach zmiennych, odwiedź C # typy i zmienne (oficjalne dokumenty C #).

Boolean (bool)

  • Typ danych Boolean ma dwie możliwe wartości: truelubfalse
  • Wartość domyślna :false
  • Zmienne logiczne są zwykle używane do sprawdzania warunków, takich jak instrukcje if, pętle itp.

Na przykład:

 using System; namespace DataType ( class BooleanExample ( public static void Main(string() args) ( bool isValid = true; Console.WriteLine(isValid); ) ) )

Kiedy uruchomimy program, wynik będzie:

 Prawdziwe

Podpisana Całka

Te typy danych zawierają wartości całkowite (dodatnie i ujemne). Z wszystkich dostępnych bitów jeden bit jest używany na znak.

1. sbyte

  • Size: 8 bits
  • Range: -128 to 127.
  • Default value: 0

For example:

 using System; namespace DataType ( class SByteExample ( public static void Main(string() args) ( sbyte level = 23; Console.WriteLine(level); ) ) )

When we run the program, the output will be:

 23

Try assigning values out of range i.e. less than -128 or greater than 127 and see what happens.

2. short

  • Size: 16 bits
  • Range: -32,768 to 32,767
  • Default value: 0

For example:

 using System; namespace DataType ( class ShortExample ( public static void Main(string() args) ( short value = -1109; Console.WriteLine(value); ) ) )

When we run the program, the output will be:

 -1109

3. int

  • Size: 32 bits
  • Range: -231 to 231-1
  • Default value: 0

For example:

 using System; namespace DataType ( class IntExample ( public static void Main(string() args) ( int score = 51092; Console.WriteLine(score); ) ) )

When we run the program, the output will be:

 51092

4. long

  • Size: 64 bits
  • Range: -263 to 263-1
  • Default value: 0L (L at the end represent the value is of long type)

For example:

 using System; namespace DataType ( class LongExample ( public static void Main(string() args) ( long range = -7091821871L; Console.WriteLine(range); ) ) )

When we run the program, the output will be:

 -7091821871

Unsigned Integral

These data types only hold values equal to or greater than 0. We generally use these data types to store values when we are sure, we won't have negative values.

1. byte

  • Size: 8 bits
  • Range: 0 to 255.
  • Default value: 0

For example:

 using System; namespace DataType ( class ByteExample ( public static void Main(string() args) ( byte age = 62; Console.WriteLine(level); ) ) )

When we run the program, the output will be:

 62

2. ushort

  • Size: 16 bits
  • Range: 0 to 65,535
  • Default value: 0

For example:

 using System; namespace DataType ( class UShortExample ( public static void Main(string() args) ( ushort value = 42019; Console.WriteLine(value); ) ) )

When we run the program, the output will be:

 42019

3. uint

  • Size: 32 bits
  • Range: 0 to 232-1
  • Default value: 0

For example:

 using System; namespace DataType ( class UIntExample ( public static void Main(string() args) ( uint totalScore = 1151092; Console.WriteLine(totalScore); ) ) )

When we run the program, the output will be:

 1151092

4. ulong

  • Size: 64 bits
  • Range: 0 to 264-1
  • Default value: 0

For example:

 using System; namespace DataType ( class ULongExample ( public static void Main(string() args) ( ulong range = 17091821871L; Console.WriteLine(range); ) ) )

When we run the program, the output will be:

 17091821871

Floating Point

These data types hold floating point values i.e. numbers containing decimal values. For example, 12.36, -92.17, etc.

1. float

  • Single-precision floating point type
  • Size: 32 bits
  • Range: 1.5 × 10−45 to 3.4 × 1038
  • Default value: 0.0F (F at the end represent the value is of float type)

For example:

 using System; namespace DataType ( class FloatExample ( public static void Main(string() args) ( float number = 43.27F; Console.WriteLine(number); ) ) )

When we run the program, the output will be:

 43.27

2. double

  • Double-precision floating point type. What is the difference between single and double precision floating point?
  • Size: 64 bits
  • Range: 5.0 × 10−324 to 1.7 × 10308
  • Default value: 0.0D (D at the end represent the value is of double type)

For example:

 using System; namespace DataType ( class DoubleExample ( public static void Main(string() args) ( double value = -11092.53D; Console.WriteLine(value); ) ) )

When we run the program, the output will be:

 -11092.53

Character (char)

  • It represents a 16 bit unicode character.
  • Size: 16 bits
  • Default value: ''
  • Range: U+0000 ('u0000') to U+FFFF ('uffff')

For example: 

 using System; namespace DataType ( class CharExample ( public static void Main(string() args) ( char ch1 ='u0042'; char ch2 = 'x'; Console.WriteLine(ch1); Console.WriteLine(ch2); ) ) )

When we run the program, the output will be:

 B x

The unicode value of 'B' is 'u0042', hence printing ch1 will print 'B'.

Decimal

  • Decimal type has more precision and a smaller range as compared to floating point types (double and float). So it is appropriate for monetary calculations.
  • Size: 128 bits
  • Default value: 0.0M (M at the end represent the value is of decimal type)
  • Range: (-7.9 x 1028 to 7.9 x 1028) / (100 to 28)

For example: 

 using System; namespace DataType ( class DecimalExample ( public static void Main(string() args) ( decimal bankBalance = 53005.25M; Console.WriteLine(bankBalance); ) ) )

When we run the program, the output will be:

 53005.25

The suffix M or m must be added at the end otherwise the value will be treated as a double and an error will be generated.

C# Literals

Let's look at the following statement:

 int number = 41;

Here,

  • int is a data type
  • number is a variable and
  • 41 is a literal

Literals are fixed values that appear in the program. They do not require any computation. For example, 5, false, 'w' are literals that appear in a program directly without any computation.

Boolean Literals

  • true and false are the available boolean literals.
  • They are used to initialize boolean variables.

For example:

 bool isValid = true; bool isPresent = false;

Integer Literals

  • Integer literals are used to initialize variables of integer data types i.e. sbyte, short, int, long, byte, ushort, uint and ulong.
  • If an integer literal ends with L or l, it is of type long. For best practice use L (not l). 
     long value1 = 4200910L; long value2 = -10928190L;
  • If an integer literal starts with a 0x, it represents hexadecimal value. Number with no prefixes are treated as decimal value. Octal and binary representation are not allowed in C#. 
     int decimalValue = 25; int hexValue = 0x11c;// decimal value 284

Floating Point Literals

  • Floating point literals are used to initialize variables of float and double data types.
  • If a floating point literal ends with a suffix f or F, it is of type float. Similarly, if it ends with d or D, it is of type double. If neither of the suffix is present, it is of type double by default.
  • These literals contains e or E when expressed in scientific notation. 
     double number = 24.67;// double by default float value = -12.29F; double scientificNotation = 6.21e2;// equivalent to 6.21 x 102 i.e. 621

Character and String Literals

  • Character literals are used to initialize variables of char data types.
  • Character literals are enclosed in single quotes. For example, 'x', 'p', etc.
  • They can be represented as character, hexadecimal escape sequence, unicode representation or integral values casted to char. 
     char ch1 = 'R'; // character char ch2 = ' x0072'; // hexadecimal char ch3 = ' u0059'; // unicode char ch4 = (char) 107; // rzutowane z liczby całkowitej
  • Literały ciągów to zbiór literałów znaków.
  • Są ujęte w podwójne cudzysłowy. Na przykład „Witaj”, „Łatwe programowanie” itp. 
    string firstName = "Richard"; string lastName = "Feynman";
  • C # obsługuje również znaki sekwencji ucieczki, takie jak:
    Postać Znaczenie
    \' Pojedynczy cudzysłów
    " Cudzysłów
    \ Ukośnik wsteczny
    Nowa linia
    Powrót karetki
    Zakładka pozioma
    a Alarm
     Backspace

Interesujące artykuły...