Premenné C # a (primitívne) dátové typy

V tomto tutoriále sa dozvieme o premenných, ako vytvárať premenné v C # a o rôznych údajových typoch, ktoré programovací jazyk C # podporuje.

Premenná je symbolický názov daný miestu v pamäti. Premenné sa používajú na ukladanie údajov do počítačového programu.

Ako deklarovať premenné v C #?

Tu je príklad deklarácie premennej v C #.

 int vek;

V tomto príklade intje deklarovaný variabilný vek typu (celé číslo), ktorý môže ukladať iba celočíselné hodnoty.

Neskôr môžeme v našom programe priradiť hodnotu premennej napríklad takto:

 int vek;……… vek = 24;

Premennú však možno počas deklarácie inicializovať aj na nejakú hodnotu. Napríklad,

 int vek = 24;

Tu intsa deklaruje a inicializuje variabilný vek typu 24súčasne.

Pretože je to premenná, môžeme zmeniť aj hodnotu premenných. Napríklad,

int vek = 24; vek = 35;

Tu sa hodnota veku zmení na 35 z 24.

Pred použitím premenných v C # musia byť deklarované. To znamená, že predtým, ako im bude možné priradiť hodnotu, musí byť známy názov a typ premennej. Z tohto dôvodu sa C # nazýva staticky napísaný jazyk.

Po deklarácii nemožno dátový typ premennej v rámci rozsahu zmeniť. Rozsah možno považovať za blok kódu, kde je premenná viditeľná alebo je k dispozícii na použitie. Ak nerozumiete predchádzajúcemu tvrdeniu, nebojte sa, o podrobnostiach sa dozvieme v ďalších kapitolách.

Teraz si pamätajte, že v C # nemôžeme robiť nasledovné:

int vek; vek = 24;……… plavákový vek;

Implicitne zadané premenné

Alternatívne v C # môžeme deklarovať premennú bez znalosti jej typu pomocou varkľúčového slova. Takéto premenné sa nazývajú lokálne premenné implicitne zadaného typu .

Premenné deklarované pomocou varkľúčového slova musia byť inicializované v čase deklarácie.

 hodnota var = 5;

Kompilátor určuje typ premennej z hodnoty, ktorá je k premennej priradená. Vo vyššie uvedenom príklade je hodnota typu int. Toto je ekvivalentné s:

hodnota int; hodnota = 5;

Môžete sa dozvedieť viac o implicitne zadaných miestnych premenných.

Pravidlá pre pomenovávanie premenných v C #

Pri pomenovávaní premennej musíme dodržiavať určité pravidlá. Pravidlá pre pomenovanie premennej v C # sú:

  1. Názov premennej môže obsahovať iba písmená (veľké a malé písmená), podčiarknutie (_) a iba číslice.
  2. Názov premennej musí začínať písmenom, znakom podčiarknutia alebo symbolom @. Napríklad pravidlá pre pomenovanie premenných v C #
    Premenné názvy Poznámky
    názov Platný
    predmet101 Platný
    _Vek Platné (osvedčený postup na pomenovanie premenných súkromných členov)
    @prestávka Platné (Používa sa, ak je názov vyhradeným kľúčovým slovom)
    101 predmet Neplatné (začína sa číslicou)
    tvoje meno Platný
    tvoje meno Neplatné (obsahuje medzery)
  3. C # rozlišuje veľké a malé písmená. Znamená to, že vek sa vzťahuje na 2 rôzne premenné.
  4. Názov premennej nesmie byť kľúčovým slovom C #. Napríklad if, for, usingnemôže byť názov premennej. V ďalšom tutoriále si povieme viac o C # kľúčových slovách.

Osvedčené postupy pre pomenovanie premennej

  1. Vyberte názov premennej, ktorý dáva zmysel. Napríklad meno, vek, predmet má väčší zmysel ako n, a a s.
  2. Na pomenovanie lokálnych premenných použite notáciu camelCase (začína sa malým písmenom). Napríklad numberOfStudents, age atď.
  3. Na pomenovanie verejných členských premenných použite PascalCase alebo CamelCase (začína sa veľkým písmenom). Napríklad krstné meno, cena atď.
  4. Na pomenovanie premenných súkromných členov použite úvodné podčiarkovník (_) a za nimi notáciu camelCase . Napríklad _bankBalance, _emailAddress atď.

Viac informácií o pomenovacích konvenciách v C # sa dozviete tu.

Nerobte si starosti s verejnými a súkromnými premennými členov. Dozvieme sa o nich v ďalších kapitolách.

C # primitívne dátové typy

Premenné v C # sú všeobecne klasifikované do dvoch typov: typy hodnôt a referenčné typy . V tomto výučbe sa budeme zaoberať primitívnymi (jednoduchými) dátovými typmi, ktoré sú podtriedou hodnotových typov.

Referenčným typom sa budeme venovať v ďalších tutoriáloch. Ak sa však chcete dozvedieť viac o typoch premenných, navštívte C # typy a premenné (oficiálne dokumenty C #).

Boolean (bool)

  • Boolovský dátový typ má dve možné hodnoty: truealebofalse
  • Predvolená hodnota :false
  • Booleovské premenné sa zvyčajne používajú na kontrolu podmienok, ako sú príkazy if, slučky atď.

Napríklad:

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

Keď spustíme program, výstup bude:

 Pravdaže

Podpísané integrálne

Tieto dátové typy obsahujú celočíselné hodnoty (kladné aj záporné). Z celkového počtu dostupných bitov sa jeden bit použije na znamienko.

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'; // znak char ch2 = ' x0072'; // hexadecimálny znak ch3 = ' u0059'; // unicode char ch4 = (char) 107; // odliate z celého čísla
  • Sláčikové literály sú kolekciou znakových literálov.
  • Sú uvedené v úvodzovkách. Napríklad „Dobrý deň“, „Jednoduché programovanie“ atď. 
    string firstName = "Richard"; string lastName = "Feynman";
  • C # podporuje aj únikové sekvenčné znaky, ako napríklad:
    Postava Význam
    \' Jednotná ponuka
    " Dvojitá citácia
    \ Spätné lomítko
    Nový riadok
    Návrat vozíka
    Vodorovná tab
    a Výstraha
     Backspace

Zaujímavé články...