C # Proměnné a (primitivní) datové typy

V tomto kurzu se dozvíme o proměnných, jak vytvářet proměnné v C # a různých datových typech, které programovací jazyk C # podporuje.

Proměnná je symbolický název daný umístění v paměti. Proměnné se používají k ukládání dat v počítačovém programu.

Jak deklarovat proměnné v C #?

Zde je příklad deklarace proměnné v C #.

 int věk;

V tomto příkladu intje deklarován proměnný věk typu (celé číslo) a může ukládat pouze celočíselné hodnoty.

Můžeme proměnné přiřadit hodnotu později v našem programu, například:

 int age;……… věk = 24;

Proměnnou však lze během deklarace také inicializovat na nějakou hodnotu. Například,

 int věk = 24;

Zde intje deklarován a inicializován proměnný věk typu 24současně.

Jelikož se jedná o proměnnou, můžeme také změnit hodnotu proměnných. Například,

int věk = 24; věk = 35;

Zde se hodnota věku změní na 35 z 24.

Proměnné v C # musí být deklarovány před tím, než je lze použít. To znamená, že před přiřazením hodnoty musí být znám název a typ proměnné. To je důvod, proč se C # nazývá staticky psaný jazyk.

Jakmile je deklarován, datový typ proměnné nelze v rámci oboru změnit. Rozsah lze považovat za blok kódu, kde je proměnná viditelná nebo je k dispozici k použití. Pokud nerozumíte předchozímu prohlášení, nebojte se, o oborech se dozvíme v dalších kapitolách.

Prozatím si pamatujte, že v C # nemůžeme dělat následující:

int věk; age = 24;……… float age;

Implicitně zadané proměnné

Alternativně v C # můžeme deklarovat proměnnou bez znalosti jejího typu pomocí varklíčového slova. Takové proměnné se nazývají implicitně zadané místní proměnné .

Proměnné deklarované pomocí varklíčového slova musí být inicializovány v době deklarace.

 var hodnota = 5;

Kompilátor určuje typ proměnné z hodnoty přiřazené proměnné. Ve výše uvedeném příkladu je hodnota typu int. To odpovídá:

hodnota int; hodnota = 5;

Můžete se dozvědět více o implicitně zadaných místních proměnných.

Pravidla pro pojmenování proměnných v C #

Při pojmenovávání proměnné musíme dodržovat určitá pravidla. Pravidla pro pojmenování proměnné v C # jsou:

  1. Název proměnné může obsahovat pouze písmena (velká a malá písmena), podtržítko (_) a pouze číslice.
  2. Název proměnné musí začínat písmenem, podtržítkem nebo symbolem @. Například Pravidla pro pojmenování proměnných v C #
    Proměnná jména Poznámky
    název Platný
    předmět 101 Platný
    _stáří Platné (Osvědčený postup pro pojmenování proměnných soukromých členů)
    @přestávka Platné (Používá se, pokud je název rezervovaným klíčovým slovem)
    101 předmět Neplatné (začíná číslicí)
    tvé jméno Platný
    tvé jméno Neplatné (obsahuje mezery)
  3. C # rozlišuje velká a malá písmena. To znamená, že věk a věk se vztahuje na 2 různé proměnné.
  4. Název proměnné nesmí být klíčové slovo C #. Například if, for, usingnemůže být název proměnné. V dalším kurzu budeme diskutovat více o klíčových slovech C #.

Osvědčené postupy pro pojmenování proměnné

  1. Vyberte název proměnné, který dává smysl. Například jméno, věk, předmět má větší smysl než n, a a s.
  2. Pro pojmenování lokálních proměnných použijte notaci camelCase (začíná malým písmenem). Například numberOfStudents, age atd.
  3. Pro pojmenování veřejných členských proměnných použijte PascalCase nebo CamelCase (začíná velkým písmenem). Například FirstName, Price atd.
  4. Pro pojmenování proměnných soukromých členů použijte úvodní podtržítko (_) následované notací camelCase . Například _bankBalance, _emailAddress atd.

Další informace o konvencích pojmenování v C # se můžete dozvědět zde.

Nedělejte si starosti s veřejnými a soukromými proměnnými členů. Dozvíme se o nich v dalších kapitolách.

C # primitivní datové typy

Proměnné v C # jsou obecně klasifikovány do dvou typů: typy hodnot a typy odkazů . V tomto tutoriálu budeme diskutovat o primitivních (jednoduchých) datových typech, což je podtřída typů hodnot.

Referenčním typům se budeme věnovat v dalších kurzech. Pokud se však chcete dozvědět více o typech proměnných, navštivte C # typy a proměnné (oficiální dokumenty C #).

Boolean (bool)

  • Booleovský datový typ má dvě možné hodnoty: truenebofalse
  • Výchozí hodnota :false
  • Booleovské proměnné se obecně používají ke kontrole podmínek, jako jsou příkazy if, smyčky atd.

Například:

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

Když spustíme program, výstup bude:

 Skutečný

Podepsaný integrál

Tyto datové typy obsahují celočíselné hodnoty (kladné i záporné). Z celkového počtu dostupných bitů se pro znaménko použije jeden bit.

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ální char ch3 = ' u0059'; // unicode char ch4 = (char) 107; // přetypováno z celého čísla
  • Řetězcové literály jsou kolekce literálů znaků.
  • Jsou uzavřeny v uvozovkách. Například „Hello“, „Easy Programming“ atd. 
    řetězec firstName = "Richard"; string lastName = "Feynman";
  • C # také podporuje znaky escape sekvence, jako například:
    Charakter Význam
    \' Jednoduchá nabídka
    " Dvojitá nabídka
    \ Obrácené lomítko
    Nový řádek
    Návrat vozíku
    Horizontální tab
    a Výstraha
     Backspace

Zajímavé články...