C # -variabelen en (primitieve) gegevenstypen

In deze tutorial zullen we leren over variabelen, hoe variabelen in C # gemaakt kunnen worden en verschillende gegevenstypen die de programmeertaal C # ondersteunt.

Een variabele is een symbolische naam die aan een geheugenlocatie wordt gegeven. Variabelen worden gebruikt om gegevens in een computerprogramma op te slaan.

Hoe variabelen in C # declareren?

Hier is een voorbeeld om een ​​variabele in C # te declareren.

 int leeftijd;

In dit voorbeeld wordt een variabele leeftijd van het type int(integer) gedeclareerd en kan deze alleen gehele getallen opslaan.

We kunnen later in ons programma een waarde aan de variabele toekennen, zoals:

 int leeftijd;……… leeftijd = 24;

De variabele kan echter ook tijdens de declaratie op een bepaalde waarde worden geïnitialiseerd. Bijvoorbeeld,

 int leeftijd = 24;

Hier wordt een variabele leeftijd van het type intgedeclareerd en tegelijkertijd geïnitialiseerd 24.

Omdat het een variabele is, kunnen we ook de waarde van variabelen wijzigen. Bijvoorbeeld,

int leeftijd = 24; leeftijd = 35;

Hier wordt de waarde van leeftijd gewijzigd in 35 van 24.

Variabelen in C # moeten worden gedeclareerd voordat ze kunnen worden gebruikt. Dit betekent dat de naam en het type variabele bekend moeten zijn voordat ze een waarde kunnen krijgen. Dit is de reden waarom C # een statisch getypeerde taal wordt genoemd.

Eenmaal gedeclareerd, kan het datatype van een variabele niet binnen een bereik worden gewijzigd. Een scope kan worden gezien als een codeblok waar de variabele zichtbaar of beschikbaar is voor gebruik. Als u de vorige verklaring niet begrijpt, hoeft u zich geen zorgen te maken, we zullen in de latere hoofdstukken meer over scopes leren.

Onthoud voorlopig dat we het volgende niet kunnen doen in C #:

int leeftijd; leeftijd = 24;……… float leeftijd;

Impliciet getypte variabelen

Als alternatief kunnen we in C # een variabele declareren zonder het type te kennen met behulp van een vartrefwoord. Dergelijke variabelen worden impliciet getypeerde lokale variabelen genoemd .

Variabelen die zijn gedeclareerd met behulp van vartrefwoord, moeten worden geïnitialiseerd op het moment van declaratie.

 var waarde = 5;

De compiler bepaalt het type variabele uit de waarde die aan de variabele is toegewezen. In het bovenstaande voorbeeld is waarde van het type int. Dit komt overeen met:

int waarde; waarde = 5;

U kunt meer leren over impliciet getypte lokale variabelen.

Regels voor het benoemen van variabelen in C #

Er zijn bepaalde regels die we moeten volgen bij het benoemen van een variabele. De regels voor het benoemen van een variabele in C # zijn:

  1. De variabelenaam mag alleen letters (hoofdletters en kleine letters), onderstrepingstekens (_) en cijfers bevatten.
  2. De variabelenaam moet beginnen met een letter, een onderstrepingsteken of een @ -symbool. Regels voor het benoemen van variabelen in C #
    Variabele namen Opmerkingen
    naam Geldig
    onderwerp101 Geldig
    _leeftijd Geldig (aanbevolen procedure voor het benoemen van variabelen van privéleden)
    @breken Geldig (gebruikt als naam een ​​gereserveerd trefwoord is)
    101onderwerp Ongeldig (begint met een cijfer)
    uw naam Geldig
    uw naam Ongeldig (bevat witruimte)
  3. C # is hoofdlettergevoelig. Het betekent dat leeftijd en leeftijd verwijzen naar 2 verschillende variabelen.
  4. Een variabelenaam mag geen C # -zoekwoord zijn. Bijvoorbeeld if, for, usingkan geen naam van een variabele zijn. In de volgende tutorial zullen we meer over C # -zoekwoorden bespreken.

Best practices voor het benoemen van een variabele

  1. Kies een logische variabelenaam. Naam, leeftijd, onderwerp is bijvoorbeeld logischer dan n, a en s.
  2. Gebruik camelCase- notatie (begint met kleine letters) voor het benoemen van lokale variabelen. Bijvoorbeeld numberOfStudents, leeftijd, etc.
  3. Gebruik PascalCase of CamelCase (begint met een hoofdletter) voor het benoemen van variabelen van openbare leden. Bijvoorbeeld Voornaam, Prijs, etc.
  4. Gebruik een vooraanstaand onderstrepingsteken (_) gevolgd door camelCase- notatie voor het benoemen van variabelen van privéleden . Bijvoorbeeld _bankBalance, _emailAddress, etc.

U kunt hier meer lezen over naamgevingsconventies in C #.

Maak je geen zorgen over variabelen van publieke en private leden. We zullen er in latere hoofdstukken over leren.

C # Primitieve gegevenstypen

Variabelen in C # worden grofweg in twee typen ingedeeld: waardetypen en referentietypes . In deze tutorial zullen we het hebben over primitieve (eenvoudige) gegevenstypen, wat een subklasse is van waardetypes.

Referentietypen worden in latere tutorials behandeld. Als u echter meer wilt weten over typen variabelen, gaat u naar C # Typen en variabelen (officiële C # -documenten).

Boolean (bool)

  • Booleaans gegevenstype heeft twee mogelijke waarden: trueoffalse
  • Standaardwaarde :false
  • Booleaanse variabelen worden over het algemeen gebruikt om voorwaarden te controleren, zoals in if-statements, loops, etc.

Bijvoorbeeld:

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

Wanneer we het programma uitvoeren, is de uitvoer:

 Klopt

Getekend integraal

Deze gegevenstypen bevatten gehele getallen (zowel positief als negatief). Van het totaal aantal beschikbare bits wordt één bit gebruikt voor teken.

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'; // hexadecimale char ch3 = ' u0059'; // unicode char ch4 = (char) 107; // casted from integer
  • String-literals zijn de verzameling letterlijke tekens.
  • Ze staan ​​tussen dubbele aanhalingstekens. Bijvoorbeeld "Hallo", "Eenvoudig programmeren", enz. 
    string firstName = "Richard"; string lastName = "Feynman";
  • C # ondersteunt ook escape-reeksen zoals:
    Karakter Betekenis
    \' Alleenstaande citaat
    " Dubbele aanhalingstekens
    \ Backslash
    Nieuwe lijn
    Vervoer terug
    Horizontaal tabblad
    a Alert
     Backspace

Interessante artikelen...