C # -variabler og (primitive) datatyper

I denne opplæringen vil vi lære om variabler, hvordan du lager variabler i C # og forskjellige datatyper som C # programmeringsspråk støtter.

En variabel er et symbolsk navn gitt til en minneplassering. Variabler brukes til å lagre data i et dataprogram.

Hvordan erklærer jeg variabler i C #?

Her er et eksempel på å erklære en variabel i C #.

 int alder;

I dette eksemplet blir en variabel alder av typen int(heltall) deklarert, og den kan bare lagre heltallverdier.

Vi kan tilordne en verdi til variabelen senere i programmet vårt slik:

 int alder;……… alder = 24;

Imidlertid kan variabelen også initialiseres til en viss verdi under erklæringen. For eksempel,

 int alder = 24;

Her blir en variabel alder av typen intdeklarert og initialisert til 24samtidig.

Siden det er en variabel, kan vi også endre verdien på variabler. For eksempel,

int alder = 24; alder = 35;

Her endres verdien av alder til 35 fra 24.

Variabler i C # må deklareres før de kan brukes. Dette betyr at navnet og typen av variabel må være kjent før de kan tildeles en verdi. Dette er grunnen til at C # kalles et statisk skrevet språk.

Når den er erklært, kan ikke datatypen til en variabel endres innenfor et omfang. Et omfang kan tenkes som en blokk med kode der variabelen er synlig eller tilgjengelig for bruk. Hvis du ikke forstår den forrige uttalelsen, ikke bekymre deg, vi lærer om omfang i de senere kapitlene.

For nå husk at vi ikke kan gjøre følgende i C #:

int alder; alder = 24;……… flytealder;

Implisitt typte variabler

Alternativt i C # kan vi deklarere en variabel uten å vite hvilken type vi bruker ved hjelp av varnøkkelord. Slike variabler kalles implisitt typte lokale variabler .

Variabler deklarert ved hjelp av varnøkkelord må initialiseres på erklæringstidspunktet.

 var verdi = 5;

Kompilatoren bestemmer typen variabel fra verdien som er tilordnet variabelen. I eksemplet ovenfor er verdien av typen int. Dette tilsvarer:

int verdi; verdi = 5;

Du kan lære mer om implisitt typte lokale variabler.

Regler for navngivning av variabler i C #

Det er visse regler vi må følge når vi navngir en variabel. Reglene for å navngi en variabel i C # er:

  1. Variabelnavnet kan bare inneholde bokstaver (store og små bokstaver), understreking (_) og sifre.
  2. Variabelnavnet må starte med enten bokstav, understrek eller @ symbol. For eksempel regler for navngivning av variabler i C #
    Variable Navn Merknader
    Navn Gyldig
    emne101 Gyldig
    _alder Gyldig (beste fremgangsmåten for å navngi private medlemsvariabler)
    @gå i stykker Gyldig (brukes hvis navn er et reservert nøkkelord)
    101emne Ugyldig (starter med siffer)
    navnet ditt Gyldig
    navnet ditt Ugyldig (Inneholder mellomrom)
  3. C # er mellom store og små bokstaver. Det betyr at alder og alder refererer til to forskjellige variabler.
  4. Et variabelnavn må ikke være et C #-nøkkelord. For eksempel if, for, usingkan ikke være en variabel navn. Vi vil diskutere mer om C # nøkkelord i neste opplæring.

Beste fremgangsmåter for å navngi en variabel

  1. Velg et variabelt navn som gir mening. For eksempel gir navn, alder, subjekt mer mening enn n, a og s.
  2. Bruk camelCase- notasjon (starter med små bokstaver) for å navngi lokale variabler. For eksempel numberOfStudents, alder, etc.
  3. Bruk PascalCase eller CamelCase (starter med store bokstaver) for å navngi offentlige medlemsvariabler. For eksempel fornavn, pris osv.
  4. Bruk en ledende understrekning (_) etterfulgt av camelCase- notasjon for å navngi private medlemsvariabler. For eksempel _bankBalance, _emailAddress, etc.

Du kan lære mer om navnekonvensjoner i C # her.

Ikke bekymre deg for offentlige og private medlemsvariabler. Vi vil lære om dem i senere kapitler.

C # Primitive datatyper

Variabler i C # er i stor grad klassifisert i to typer: Verdityper og Referansetyper . I denne opplæringen vil vi diskutere primitive (enkle) datatyper som er en underklasse av verdityper.

Referansetyper vil bli dekket i senere opplæringsprogrammer. Men hvis du vil vite mer om variable typer, kan du gå til C # -typer og variabler (offisielle C # docs).

Boolsk (bool)

  • Boolsk datatype har to mulige verdier: trueellerfalse
  • Standardverdi :false
  • Boolske variabler brukes vanligvis til å kontrollere forhold som i if uttalelser, sløyfer, etc.

For eksempel:

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

Når vi kjører programmet, vil utdataene være:

 ekte

Signert integrert

Disse datatypene inneholder heltall (både positive og negative). Av de totale tilgjengelige bitene brukes en bit til tegn.

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'; // character char ch2 = ' x0072'; // hexadecimal char ch3 = ' u0059'; // unicode char ch4 = (char) 107; // casted from integer
  • Stringlitteraler er samlingen av karakterbokstaver.
  • De er omsluttet av doble anførselstegn. For eksempel "Hei", "Enkel programmering" osv. 
    string firstName = "Richard"; string lastName = "Feynman";
  • C # støtter også escape-sekvens tegn som:
    Karakter Betydning
    \' Enkelt tilbud
    " Dobbelt tilbud
    \ Backslash
    Ny linje
    Vognretur
    Horisontal fane
    a Varsling
     Backspace

Interessante artikler...