C # Változók és (primitív) adattípusok

Ebben az oktatóanyagban megismerhetjük a változókat, hogyan hozhatunk létre változókat C # -ban és különböző adattípusokat, amelyeket a C # programozási nyelv támogat.

A változó a memória helyének adott szimbolikus név. A változókat az adatok számítógépes programban történő tárolására használják.

Hogyan deklarálhatók változók C # -ben?

Itt van egy példa egy változó deklarálására a C # -ben.

 int kor;

Ebben a példában egy változó típusú int(egész) életkor van deklarálva, és csak egész értékeket képes tárolni.

A program későbbi részében hozzárendelhetünk egy értéket a változóhoz, például:

 int életkor;……… életkor = 24;

A változó azonban inicializálható valamilyen értékre is a deklarálás során. Például,

 int kor = 24;

Itt egy változó típusú életkort intdeklarálunk, és 24egyszerre inicializáljuk .

Mivel ez egy változó, megváltoztathatjuk a változók értékét is. Például,

int kor = 24; életkor = 35;

Itt az életkor értéke 24-ről 35 évre változik.

A C # -ben szereplő változókat használatuk előtt deklarálni kell. Ez azt jelenti, hogy a változó nevének és típusának ismernie kell az értéket. Ezért hívják a C # -t statikusan tipizált nyelvnek.

A deklarálás után a változó adattípusa nem módosítható egy hatókörön belül. A hatókör úgy tekinthető, mint egy kódblokk, ahol a változó látható vagy használható. Ha nem érti az előző állítást, ne aggódjon, a későbbi fejezetekben megismerhetjük a hatóköröket.

Most ne feledje, hogy a következőt nem tudjuk megtenni a C # -ban:

int kor; életkor = 24;……… úszó kor;

Implicit módon beírt változók

Alternatív megoldásként a C # -ben deklarálhatunk egy változót anélkül, hogy tudnánk a típusát a varkulcsszó segítségével . Az ilyen változókat implicit módon tipizált helyi változóknak nevezzük .

A varkulcsszóval deklarált változókat inicializálni kell a deklaráláskor.

 var érték = 5;

A fordító a változó típusát a változóhoz rendelt érték alapján határozza meg. A fenti példában az érték típusú int. Ez egyenértékű:

int érték; érték = 5;

Tudjon meg többet az implicit módon beírt helyi változókról.

A változók C # -ben való elnevezésének szabályai

Van egy bizonyos szabály, amelyet be kell tartanunk egy változó megnevezése közben. A változó elnevezésének a C # szabályai a következők:

  1. A változó neve csak betűket (nagy- és kisbetűket), aláhúzást (_) és számjegyeket tartalmazhat.
  2. A változó nevének betűvel, aláhúzással vagy @ szimbólummal kell kezdődnie. Például a változók elnevezésének szabályai a C #
    Változó nevek Megjegyzések
    név Érvényes
    tárgy101 Érvényes
    _kor Érvényes (legjobb gyakorlat a magántag-változók elnevezéséhez)
    @szünet Érvényes (akkor használatos, ha a név lefoglalt kulcsszó)
    101tárgy Érvénytelen (számjeggyel kezdődik)
    a neved Érvényes
    a neved Érvénytelen (szóközt tartalmaz)
  3. A C # kis- és nagybetű érzékeny. Ez azt jelenti, hogy az életkor és az életkor két különböző változóra utal.
  4. A változó neve nem lehet C # kulcsszó. Például if, for, usingnem lehet egy változó nevét. A következő oktatóanyagban többet fogunk megvitatni a C # kulcsszavakról.

A változó elnevezésének legjobb gyakorlatai

  1. Válasszon értelmes változónevet. Például a név, az életkor, az alany értelmesebb, mint n, a és s.
  2. A helyi változók elnevezéséhez használja a camelCase jelölést (kisbetűvel kezdődik). Például a numberOfStudents, az életkor stb.
  3. Használja a PascalCase vagy a CamelCase (nagybetűvel kezdődik) neveket a nyilvános tag változók elnevezéséhez. Például keresztnév, ár stb.
  4. Használjon vezető aláhúzást (_), majd a camelCase jelölést a privát tag változók elnevezéséhez. Például _bankBalance, _emailAddress stb.

A C # elnevezési szokásokról itt tudhat meg többet.

Ne aggódjon a nyilvános és a privát tag változók miatt. A későbbi fejezetekben megismerjük őket.

C # primitív adattípusok

A C # -ben szereplő változókat nagyjából két típusba sorolják: Értéktípusok és Referencia típusok . Ebben az oktatóanyagban a primitív (egyszerű) adattípusokról fogunk tárgyalni, amely az Értéktípusok alosztálya.

A referencia típusokra a későbbi oktatóanyagok foglalkoznak. Ha azonban többet szeretne megtudni a változó típusokról, látogasson el a C # típusok és változók (hivatalos C # dokumentumok) oldalra.

Logikai (logikai)

  • A logikai adattípusnak két lehetséges értéke van: truevagyfalse
  • Alapértelmezett érték :false
  • A logikai változókat általában olyan feltételek ellenőrzésére használják, mint például ha utasítások, ciklusok stb.

Például:

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

A program futtatásakor a kimenet a következő lesz:

 Igaz

Aláírt Integral

Ezek az adattípusok egész (pozitív és negatív) értékeket tartalmaznak. Az összes rendelkezésre álló bit közül egy bitet használunk az aláírásra.

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'; // karakter char ch2 = ' x0072'; // hexadecimális char ch3 = ' u0059'; // unicode char ch4 = (char) 107; // egész számból öntve
  • A karakterláncok a karakterliterek gyűjteménye.
  • Ezeket dupla idézőjelek tartalmazzák. Például: "Hello", "Easy Programming" stb. 
    string firstName = "Richard"; string lastName = "Feynman";
  • A C # olyan menekülési szekvencia karaktereket is támogat, mint:
    karakter Jelentése
    \' Egyetlen idézet
    " Dupla idézet
    \ Visszavágás
    Új sor
    Kocsi vissza
    Vízszintes fül
    a Éber
     Backspace

érdekes cikkek...