C # muutujad ja (primitiivsed) andmetüübid

Selles õpetuses õpime muutujate kohta, kuidas luua muutujaid C # -s ja erinevaid andmetüüpe, mida C # programmeerimiskeel toetab.

Muutuja on mälu asukohale antud sümboolne nimi. Muutujaid kasutatakse andmete salvestamiseks arvutiprogrammi.

Kuidas deklareerida muutujad C # -s?

Siin on näide muutuja deklareerimiseks C # -s.

 int vanus;

Selles näites intdeklareeritakse tüübi (täisarv) muutuv vanus ja see saab salvestada ainult täisarvu väärtusi.

Saame muutujale oma programmis hiljem väärtuse määrata:

 int vanus;……… vanus = 24;

Muutuja saab deklareerimise ajal siiski lähtestada ka mõnele väärtusele. Näiteks,

 int vanus = 24;

Siin intdeklareeritakse muutuv vanuse tüüp ja lähtestatakse 24samal ajal.

Kuna see on muutuja, saame ka muutujate väärtust muuta. Näiteks,

int vanus = 24; vanus = 35;

Siin muudetakse vanuse väärtus 35-le 24-st.

Enne nende kasutamist tuleb deklareerida muutujad koodis C #. See tähendab, et enne väärtuse määramist peab muutuja nimi ja tüüp olema teada. Seetõttu nimetatakse C # -d staatiliselt sisestatud keeleks.

Pärast deklareerimist ei saa muutuja andmetüüpi reguleerimisalas muuta. Reguleerimisala võib mõelda kui koodiplokki, kus muutuja on nähtav või saadaval. Kui te ei saa eelmisest väitest aru, ärge muretsege, me õpime ulatuse kohta järgmistest peatükkidest.

Praegu pidage meeles, et me ei saa C #-s järgmist teha:

int vanus; vanus = 24;……… ujukiga vanus;

Kaudselt sisestatud muutujad

Alternatiivina saab C # -s deklareerida muutuja varmärksõna abil selle tüüpi tundmata . Selliseid muutujaid nimetatakse kaudselt sisestatud kohalikeks muutujateks .

varMärksõna abil deklareeritud muutujad tuleb deklareerimise ajal initsialiseerida.

 var väärtus = 5;

Koostaja määrab muutuja tüübi väärtusele, mis sellele on määratud. Ülaltoodud näites on väärtus tüüpi int. See on samaväärne järgmisega:

int väärtus; väärtus = 5;

Lisateavet kaudselt sisestatud kohalike muutujate kohta.

C # muutujate nimetamise reeglid

Muutuja nimetamisel peame järgima teatud reegleid. Muutuja C # nimetamise reeglid on järgmised:

  1. Muutuja nimi võib sisaldada ainult tähti (suurtähti ja väiketähti), alakriipsu (_) ja numbreid.
  2. Muutuja nimi peab algama kas tähe, alakriipsuga või sümboliga @. Näiteks reeglid muutujate nimetamiseks C #
    Muutuja nimed Märkused
    nimi Kehtib
    teema101 Kehtib
    _vanus Kehtib (parim tava eraisikute muutujate nimetamiseks)
    @break Kehtib (kasutatakse, kui nimi on reserveeritud märksõna)
    101subjekt Kehtetu (algab numbriga)
    sinu nimi Kehtib
    sinu nimi Kehtetu (sisaldab tühikut)
  3. C # on tõstutundlik. See tähendab vanust ja vanus viitab kahele erinevale muutujale.
  4. Muutuja nimi ei tohi olla C # märksõna. Näiteks if, for, usingei saa olla muutuja nimi. Järgmises õpetuses arutame C # märksõnade kohta lähemalt.

Parimad muutuja nimetamise tavad

  1. Valige mõistlik muutuja nimi. Näiteks on nimi, vanus, subjekt mõistlikum kui n, a ja s.
  2. Kohalike muutujate nimetamiseks kasutage märki camelCase (algab väiketähega). Näiteks numberOfStudents, vanus jne.
  3. Avalike liikmete muutujate nimetamiseks kasutage PascalCase'i või CamelCase'i (algab suurtähega). Näiteks eesnimi, hind jne.
  4. Privaatliikme muutujate nimetamiseks kasutage juhtivat alljooni (_), millele järgneb camelCase märge. Näiteks _bankBalance, _emailAddress jne.

Siit leiate lisateavet C # -is nimetamiskonventsioonide kohta.

Ärge muretsege avaliku ja erasektori liikmete muutujate pärast. Nende kohta saame teada järgmistest peatükkidest.

C # primitiivsed andmetüübid

Muutujad kategoorias C on liigitatud laias laastus kahte tüüpi: väärtuse tüübid ja viite tüübid . Selles õpetuses käsitleme primitiivseid (lihtsaid) andmetüüpe, mis on väärtuste tüüpide alamklass.

Viidetüüpe käsitletakse hilisemates õpetustes. Kui soovite aga muutujate kohta rohkem teada saada, külastage lehte C # tüübid ja muutujad (ametlikud C # dokumendid).

Loogiline (bool)

  • Boole'i ​​andmetüübil on kaks võimalikku väärtust: truevõifalse
  • Vaikeväärtus :false
  • Boole'i ​​muutujaid kasutatakse tavaliselt tingimuste kontrollimiseks, näiteks lausete, tsüklite jms puhul.

Näiteks:

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

Programmi käivitamisel on väljund:

 Tõsi

Allkirjastatud lahutamatu

Need andmetüübid omavad täisarvu väärtusi (nii positiivseid kui ka negatiivseid). Kõigi saadaolevate bitide hulgast kasutatakse allkirjastamiseks ühte bitti.

1. sbyte

  • Suurus : 8 bitti
  • Vahemik : -128 kuni 127.
  • Vaikeväärtus : 0

Näiteks:

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

Programmi käivitamisel on väljund:

 23

Määrake väärtused, mis jäävad vahemikust väljapoole, st alla -128 või üle 127, ja vaadake, mis juhtub.

2. lühike

  • Suurus : 16 bitti
  • Vahemik : -32 768 kuni 32 767
  • Vaikeväärtus : 0

Näiteks:

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

Programmi käivitamisel on väljund:

 -1109

3. int

  • Suurus : 32 bitti
  • Vahemik : -231 kuni 231-1
  • Vaikeväärtus : 0

Näiteks:

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

Programmi käivitamisel on väljund:

 51092

4. pikk

  • Suurus : 64 bitti
  • Vahemik : -263 kuni 263-1
  • Vaikeväärtus : 0L(L tähistab, et väärtus on pikka tüüpi)

Näiteks:

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

Programmi käivitamisel on väljund:

 -7091821871

Allkirjastamata tervik

Nendes andmetüüpides on väärtused, mis on võrdsed või suuremad kui 0. Me kasutame neid andmetüüpe tavaliselt väärtuste salvestamiseks, kui oleme kindlad, et meil pole negatiivseid väärtusi.

1. bait

  • Suurus : 8 bitti
  • 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'; // märk char ch2 = ' x0072'; // kuueteistkümnendsüsteem char ch3 = ' u0059'; // unicode char ch4 = (char) 107; // täisarvust valatud
  • String-literaalid on tegelas-literaalide kogu.
  • Need on lisatud topelt jutumärkidesse. Näiteks "Tere", "Lihtne programmeerimine" jne. 
    stringi eesnimi = "Richard"; string lastName = "Feynman";
  • C # toetab ka selliseid põgenemisjärjestuse märke nagu:
    Iseloom Tähendus
    \' Üksik tsitaat
    " Topelttsiteerimine
    \ Tagasi kaldkriips
    Uus rida
    Vankri tagasipöördumine
    Horisontaalne vaheleht
    a Hoiatus
     Tagasilükkeklahv

Huvitavad Artiklid...