C # променливи и (примитивни) типове данни

В този урок ще научим за променливите, как да създаваме променливи в C # и различни типове данни, които C # езикът за програмиране поддържа.

Променливата е символично име, дадено на място в паметта. Променливите се използват за съхраняване на данни в компютърна програма.

Как да декларирам променливи в C #?

Ето пример за деклариране на променлива в C #.

 int възраст;

В този пример intе декларирана променлива възраст от тип (цяло число) и тя може да съхранява само цели числа.

Можем да присвоим стойност на променливата по-късно в нашата програма като такава:

 int възраст;……… възраст = 24;

Променливата обаче може да бъде инициализирана до някаква стойност по време на декларацията. Например,

 int възраст = 24;

Тук променлива възраст от тип intсе декларира и инициализира 24едновременно.

Тъй като това е променлива, можем да променим и стойността на променливите. Например,

int възраст = 24; възраст = 35;

Тук стойността на възрастта се променя на 35 от 24.

Променливите в C # трябва да бъдат декларирани, преди да могат да бъдат използвани. Това означава, че името и типът на променливата трябва да са известни, преди да им бъде присвоена стойност. Ето защо C # се нарича статически типизиран език.

След като бъде деклариран, типът данни на променлива не може да бъде променен в рамките на обхвата. Обхватът може да се разглежда като блок от код, където променливата е видима или достъпна за използване. Ако не разбирате предишното твърдение, не се притеснявайте, ще научим за обхвата в следващите глави.

Засега не забравяйте, че не можем да направим следното в C #:

int възраст; възраст = 24;……… плаваща възраст;

Неявно написани променливи

Като алтернатива в C # можем да декларираме променлива, без да знаем нейния тип, използвайки varключова дума. Такива променливи се наричат имплицитно типизирани локални променливи .

Променливите, декларирани с varключова дума, трябва да бъдат инициализирани по време на декларацията.

 стойност на var = 5;

Компилаторът определя типа променлива от стойността, която е присвоена на променливата. В горния пример стойността е от тип int. Това е еквивалентно на:

стойност int; стойност = 5;

Можете да научите повече за неявно набраните локални променливи.

Правила за именуване на променливи в C #

Има определени правила, които трябва да следваме, докато именуваме променлива. Правилата за именуване на променлива в C # са:

  1. Името на променливата може да съдържа само букви (главни и малки букви), подчертаване (_) и цифри.
  2. Името на променливата трябва да започва с буква, долна черта или символ @. Например Правила за именуване на променливи в C #
    Имена на променливи Забележки
    име Валидно
    тема101 Валидно
    _age Валидно (Най-добра практика за именуване на променливи на частни членове)
    @break Валиден (Използва се, ако името е запазена ключова дума)
    101субект Невалидно (започва с цифра)
    твоето име Валидно
    твоето име Невалидно (Съдържа празно пространство)
  3. C # е чувствителен към малки и големи букви. Това означава, че възрастта и възрастта се отнасят до 2 различни променливи.
  4. Името на променлива не трябва да е ключова дума C #. Например if, for, usingне може да бъде име на променлива. Ще обсъдим повече за ключовите думи C # в следващия урок.

Най-добри практики за именуване на променлива

  1. Изберете име на променлива, което има смисъл. Например името, възрастта, темата имат повече смисъл от n, a и s.
  2. Използвайте нотация camelCase (започва с малка буква) за именуване на локални променливи. Например, numberOfStudents, възраст и т.н.
  3. Използвайте PascalCase или CamelCase (започва с главна буква) за именуване на променливи на публичен член. Например FirstName, Price и т.н.
  4. Използвайте водеща долна черта (_), последвана от нотация camelCase за именуване на променливи на частни членове. Например _bankBalance, _emailAddress и др.

Можете да научите повече за конвенциите за именуване в C # тук.

Не се притеснявайте за публични и частни променливи членове. Ще научим за тях в следващите глави.

C # Примитивни типове данни

Променливите в C # се класифицират най-общо в два типа: типове стойности и референтни типове . В този урок ще обсъждаме примитивни (прости) типове данни, който е подклас на типовете стойност.

Референтните типове ще бъдат разгледани в следващите уроци. Ако обаче искате да научите повече за типовете променливи, посетете C # Типове и променливи (официални C # документи).

Boolean (bool)

  • Булевият тип данни има две възможни стойности: trueилиfalse
  • Стойност по подразбиране :false
  • Булевите променливи обикновено се използват за проверка на условия като в оператори if, цикли и т.н.

Например:

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

Когато стартираме програмата, изходът ще бъде:

 Вярно

Подписан интеграл

Тези типове данни съдържат цели числа (както положителни, така и отрицателни). От общите налични битове, един бит се използва за знак.

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'; // символ char ch2 = ' x0072'; // шестнадесетичен char ch3 = ' u0059'; // unicode char ch4 = (char) 107; // излято от цяло число
  • String литералите са колекцията от символни литерали.
  • Те са затворени в двойни кавички. Например "Здравей", "Лесно програмиране" и т.н. 
    низ firstName = "Ричард"; низ lastName = "Feynman";
  • C # също поддържа символи на екранираща последователност като:
    Характер Значение
    \' Единична оферта
    " Двойна кавичка
    \ Наклонена черта
    Нова линия
    Връщане на каретата
    Хоризонтален раздел
    a Тревога
     Backspace

Интересни статии...