C # -variabler och (primitiva) datatyper

I den här handledningen lär vi oss om variabler, hur man skapar variabler i C # och olika datatyper som C # programmeringsspråk stöder.

En variabel är ett symboliskt namn som ges till en minnesplats. Variabler används för att lagra data i ett datorprogram.

Hur deklarerar jag variabler i C #?

Här är ett exempel för att deklarera en variabel i C #.

 int ålder;

I det här exemplet intdeklareras en variabel ålder av typen (heltal) och den kan bara lagra heltalsvärden.

Vi kan tilldela variabeln ett värde senare i vårt program som sådant:

 int ålder; … … … ålder = 24;

Variabeln kan dock också initieras till något värde under deklarationen. Till exempel,

 int ålder = 24;

Här intdeklareras en variabel ålder av typ och initialiseras 24samtidigt.

Eftersom det är en variabel kan vi också ändra variabelns värde. Till exempel,

int ålder = 24; ålder = 35;

Här ändras åldersvärdet till 35 från 24.

Variabler i C # måste deklareras innan de kan användas. Detta innebär att namnet och typen av variabel måste vara känd innan de kan tilldelas ett värde. Det är därför som C # kallas ett statiskt skrivet språk.

En gång deklarerat kan datatypen för en variabel inte ändras inom ett omfång. Ett omfång kan ses som ett kodblock där variabeln är synlig eller tillgänglig att använda. Om du inte förstår det föregående uttalandet, oroa dig inte, vi lär dig mer om omfattningen i de senare kapitlen.

För nu, kom ihåg att vi inte kan göra följande i C #:

int ålder; ålder = 24; … … … flottörålder;

Implicit skrivna variabler

Alternativt i C # kan vi deklarera en variabel utan att känna till dess typ med hjälp av varnyckelord. Sådana variabler kallas implicit typade lokala variabler .

Variabler som deklareras med varnyckelord måste initieras vid tidpunkten för deklarationen.

 var värde = 5;

Kompilatorn bestämmer typen av variabel utifrån det värde som tilldelas variabeln. I exemplet ovan är värdet av typen int. Detta motsvarar:

int värde; värde = 5;

Du kan lära dig mer om implicit skrivna lokala variabler.

Regler för namngivning av variabler i C #

Det finns vissa regler som vi måste följa när vi heter en variabel. Reglerna för att namnge en variabel i C # är:

  1. Variabelnamnet kan endast innehålla bokstäver (stora och små bokstäver), understrykning (_) och endast siffror.
  2. Variabelnamnet måste börja med antingen bokstaven, understrykningen eller @ -symbolen. Till exempel regler för namngivning av variabler i C #
    Variabla namn Anmärkningar
    namn Giltig
    ämne101 Giltig
    _ålder Giltig (Bästa praxis för att namnge privata medlemsvariabler)
    @ha sönder Giltig (används om namn är ett reserverat nyckelord)
    101ämne Ogiltig (börjar med siffra)
    ditt namn Giltig
    ditt namn Ogiltig (Innehåller mellanslag)
  3. C # är skiftlägeskänslig. Det betyder ålder och ålder hänvisar till två olika variabler.
  4. Ett variabelnamn får inte vara ett C #-nyckelord. Till exempel if, for, usingkan inte vara ett variabelnamn. Vi kommer att diskutera mer om C #-nyckelord i nästa handledning.

Bästa metoder för att namnge en variabel

  1. Välj ett variabelt namn som är vettigt. Till exempel, namn, ålder, ämne är mer meningsfullt än n, a och s.
  2. Använd camelCase- notering (börjar med små bokstäver) för att namnge lokala variabler. Till exempel numberOfStudents, ålder etc.
  3. Använd PascalCase eller CamelCase (börjar med stora bokstäver) för att namnge offentliga medlemsvariabler. Till exempel FirstName, Price, etc.
  4. Använd en ledande understrykning (_) följt av camelCase- notering för att namnge privata medlemsvariabler. Till exempel _bankBalance, _emailAddress, etc.

Du kan lära dig mer om namngivningskonventioner i C # här.

Oroa dig inte för offentliga och privata medlemsvariabler. Vi kommer att lära oss om dem i senare kapitel.

C # Primitiva datatyper

Variabler i C # klassificeras i stort sett i två typer: Värdetyper och Referenstyper . I denna handledning kommer vi att diskutera om primitiva (enkla) datatyper som är en underklass av värdetyper.

Referenstyper kommer att behandlas i senare handledning. Men om du vill veta mer om variabeltyper, besök C # -typer och variabler (officiella C # -dokument).

Boolean (bool)

  • Boolesk datatyp har två möjliga värden: trueellerfalse
  • Standardvärde :false
  • Booleska variabler används vanligtvis för att kontrollera villkor som i if uttalanden, loopar etc.

Till exempel:

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

När vi kör programmet blir resultatet:

 Sann

Signerad integral

Dessa datatyper har helvärden (både positiva och negativa). Av de totala tillgängliga bitarna används en bit för tecken.

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'; // tecken char ch2 = ' x0072'; // hexadecimal char ch3 = ' u0059'; // unicode char ch4 = (char) 107; // gjutet från heltal
  • Strängbokstäver är samlingen av bokstäver.
  • De är bifogade i dubbla citat. Till exempel "Hej", "Enkel programmering", etc. 
    string firstName = "Richard"; string lastName = "Feynman";
  • C # stöder också escape-sekvenstecken som:
    Karaktär Menande
    \' Enkel offert
    " Dubbel offert
    \ Backslash
    Ny linje
    Vagnretur
    Fliken Horisontell
    a Varna
     Backspace

Intressanta artiklar...