C # -variabler og (primitive) datatyper

I denne vejledning lærer vi om variabler, hvordan man opretter variabler i C # og forskellige datatyper, som C # programmeringssprog understøtter.

En variabel er et symbolsk navn, der gives til en hukommelsesplacering. Variabler bruges til at gemme data i et computerprogram.

Hvordan erklæres variabler i C #?

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

 int alder

I dette eksempel interklæres en variabel alder af typen (heltal), og den kan kun gemme heltalværdier.

Vi kan tildele en værdi til variablen senere i vores program som sådan:

 int alder;……… alder = 24;

Imidlertid kan variablen også initialiseres til en vis værdi under erklæringen. For eksempel,

 int alder = 24;

Her interklæres en variabel alder af typen og initialiseres til 24samme tid.

Da det er en variabel, kan vi også ændre værdien af ​​variabler. For eksempel,

int alder = 24; alder = 35;

Her ændres værdien af ​​alder til 35 fra 24.

Variabler i C # skal deklareres, før de kan bruges. Det betyder, at navnet og typen af ​​variablen skal være kendt, før de kan tildeles en værdi. Dette er grunden til, at C # kaldes et statisk-skrevet sprog.

Når en variabel er erklæret, kan datatypen ikke ændres inden for et omfang. Et omfang kan betragtes som en blok kode, hvor variablen er synlig eller tilgængelig til brug. Hvis du ikke forstår den foregående erklæring, skal du ikke bekymre dig, vi lærer om omfang i de senere kapitler.

For nu husk, vi kan ikke gøre følgende i C #:

int alder alder = 24;……… flydealder;

Implicit typede variabler

Alternativt i C # kan vi erklære en variabel uden at kende dens type ved hjælp af varnøgleord. Sådanne variabler kaldes implicit typede lokale variabler .

Variabler, der erklæres ved hjælp af varnøgleord, skal initialiseres på erklæringstidspunktet.

 var værdi = 5;

Compileren bestemmer typen af ​​variabel ud fra den værdi, der er tildelt variablen. I ovenstående eksempel er værdien af ​​typen int. Dette svarer til:

int-værdi; værdi = 5;

Du kan lære mere om implicit typede lokale variabler.

Regler for navngivning af variabler i C #

Der er visse regler, vi skal følge, når vi navngiver en variabel. Reglerne for navngivning af en variabel i C # er:

1. Variabelnavnet kan kun indeholde bogstaver (store og små bogstaver), understregning (_) og cifre.
2. Variabelnavnet skal starte med enten bogstav, understregning eller @ symbol. For eksempel regler for navngivning af variabler i C #

   Variable navne	Bemærkninger
   navn	Gyldig
   emne101	Gyldig
   _alder	Gyldig (bedste praksis til navngivning af private medlemsvariabler)
   @pause	Gyldig (bruges hvis navn er et reserveret nøgleord)
   101emne	Ugyldig (starter med ciffer)
   dit navn	Gyldig
   dit navn	Ugyldig (Indeholder mellemrum)

3. C # er store og små bogstaver. Det betyder alder og alder henviser til 2 forskellige variabler.
4. Et variabelnavn må ikke være et C # nøgleord. For eksempel if, for, usingkan ikke være et variabelnavn. Vi vil diskutere mere om C # nøgleord i den næste vejledning.

Bedste fremgangsmåder til navngivning af en variabel

1. Vælg et variabelnavn, der giver mening. For eksempel giver navn, alder, motiv mere mening end n, a og s.
2. Use camelCase notation (starts with lowercase letter) for naming local variables. For example, numberOfStudents, age, etc.
3. Use PascalCase or CamelCase (starts with uppercase letter) for naming public member variables. For example, FirstName, Price, etc.
4. Use a leading underscore (_) followed by camelCase notation for naming private member variables. For example, _bankBalance, _emailAddress, etc.

You can learn more about naming conventions in C# here.

Don't worry about public and private member variables. We will learn about them in later chapters.

C# Primitive Data Types

Variables in C# are broadly classified into two types: Value types and Reference types. In this tutorial we will be discussing about primitive (simple) data types which is a subclass of Value types.

Reference types will be covered in later tutorials. However, if you want to know more about variable types, visit C# Types and variables (official C# docs).

Boolean (bool)

• Boolean data type has two possible values: true or false
• Default value: false
• Boolean variables are generally used to check conditions such as in if statements , loops , etc.

For Example:

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

When we run the program, the output will be:

 True

Signed Integral

These data types hold integer values (both positive and negative). Out of the total available bits, one bit is used for sign.

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'; // hexadecimal char ch3 = ' u0059'; // unicode char ch4 = (char) 107; // støbt fra heltal

• String-bogstaver er samlingen af ​​karakterbogstaver.
• De er omgivet af dobbelt anførselstegn. For eksempel "Hej", "Nem programmering" osv.

  string firstName = "Richard"; string lastName = "Feynman";

• C # understøtter også escape-sekvens tegn som:
  

  Karakter	Betyder
  \'	Enkelt tilbud
  "	Dobbelt tilbud
  \	Backslash
  	Ny linje
  	Vognretur
  	Fanen Vandret
  a	Alert
  	Backspace