Gehele getallen en drijvendekomma's gebruiken in C#

Artikel
06/21/2023

In deze zelfstudie leert u meer over de numerieke typen in C#. U schrijft kleine hoeveelheden code en vervolgens compileert en voert u die code uit. De zelfstudie bevat een reeks lessen die getallen en wiskundige bewerkingen in C# verkennen. In deze lessen krijgt u uitleg over de basisprincipes van de computertaal C#.

Tip

Als u een codefragment in de focusmodus wilt plakken, gebruikt u de sneltoets (Ctrl + v of cmd + v).

Vereisten

In de zelfstudie wordt verwacht dat u een computer hebt ingesteld voor lokale ontwikkeling. Zie Uw lokale omgeving instellen voor installatie-instructies en een overzicht van toepassingsontwikkeling in .NET.

Als u geen lokale omgeving wilt instellen, raadpleegt u de interactieve versie van deze zelfstudie.

Wiskunde verkennen met gehele getallen

Maak een map met de naam numbers-quickstart. Maak hiervan de huidige map en voer de volgende opdracht uit:

dotnet new console -n NumbersInCSharp -o .

Belangrijk

De C#-sjablonen voor .NET 6 gebruiken instructies op het hoogste niveau. Uw toepassing komt mogelijk niet overeen met de code in dit artikel als u al een upgrade naar .NET 6 hebt uitgevoerd. Zie het artikel over Nieuwe C#-sjablonen voor het genereren van instructies op het hoogste niveau voor meer informatie

De .NET 6 SDK voegt ook een set implicieteglobal using instructies toe voor projecten die gebruikmaken van de volgende SDK's:

Microsoft.NET.Sdk
Microsoft.NET.Sdk.Web
Microsoft.NET.Sdk.Worker

Deze impliciete global using instructies bevatten de meest voorkomende naamruimten voor het projecttype.

Zie het artikel over impliciete gebruiksrichtlijnen voor meer informatie

Open Program.cs in uw favoriete editor en vervang de inhoud van het bestand door de volgende code:

int a = 18;
int b = 6;
int c = a + b;
Console.WriteLine(c);

Voer deze code uit door in het opdrachtvenster te typen dotnet run .

U hebt een van de fundamentele wiskundige bewerkingen met gehele getallen gezien. Het int type vertegenwoordigt een geheel getal, een nul, een positief of negatief geheel getal. U gebruikt het symbool + als toevoeging. Andere veelgebruikte wiskundige bewerkingen voor gehele getallen zijn onder meer:

- voor aftrekken
* voor vermenigvuldigen
/ voor delen

Begin bij het verkennen van die verschillende bewerkingen. Voeg deze regels toe na de regel waarmee de waarde van cwordt geschreven:

// subtraction
c = a - b;
Console.WriteLine(c);

// multiplication
c = a * b;
Console.WriteLine(c);

// division
c = a / b;
Console.WriteLine(c);

Voer deze code uit door in het opdrachtvenster te typen dotnet run .

U kunt desgewenst ook experimenteren door meerdere wiskundige bewerkingen op dezelfde regel te schrijven. Probeer c = a + b - 12 * 17; het bijvoorbeeld. Het combineren van variabelen en constante getallen is toegestaan.

Tip

Bij de verkenning van C# (of elke andere programmeertaal) zult u fouten maken bij het schrijven van code. Het compileerprogramma vindt deze fouten en meldt deze aan u. Wanneer de uitvoer foutberichten bevat, bekijkt u de voorbeeldcode en de code in het venster om te zien wat u kunt oplossen. Deze oefening helpt u om inzicht te krijgen in de structuur van C#-code.

U hebt de eerste stap voltooid. Voordat u aan de volgende sectie begint, gaan we de huidige code naar een afzonderlijke methode verplaatsen. Een methode is een reeks instructies die zijn gegroepeerd en een naam hebben. U roept een methode aan door de naam van de methode te schrijven, gevolgd door (). Door uw code in methoden te ordenen, kunt u gemakkelijker aan de slag met een nieuw voorbeeld. Wanneer u klaar bent, moet uw code er als volgt uitzien:

WorkWithIntegers();

void WorkWithIntegers()
{
    int a = 18;
    int b = 6;
    int c = a + b;
    Console.WriteLine(c);


    // subtraction
    c = a - b;
    Console.WriteLine(c);

    // multiplication
    c = a * b;
    Console.WriteLine(c);

    // division
    c = a / b;
    Console.WriteLine(c);
}

De regel WorkWithIntegers(); roept de methode aan. De volgende code declareert de methode en definieert deze.

De volgorde van bewerkingen verkennen

Maak commentaar bij de aanroep van WorkingWithIntegers(). Hierdoor wordt de uitvoer minder overzichtelijk terwijl u in deze sectie werkt:

//WorkWithIntegers();

De // start een opmerking in C#. Opmerkingen zijn alle tekst die u in uw broncode wilt behouden, maar niet wilt uitvoeren als code. De compiler genereert geen uitvoerbare code op basis van opmerkingen. Omdat WorkWithIntegers() een methode is, hoeft u slechts één regel commentaar te geven.

Met de computertaal C# wordt de prioriteit gedefinieerd van verschillende wiskundige bewerkingen met regels die overeenkomen met de regels die u bij wiskunde hebt geleerd. Vermenigvuldigen en delen gaan voor op optellen en aftrekken. Verken dit door de volgende code toe te voegen na de aanroep van en uit te WorkWithIntegers()dotnet runvoeren:

int a = 5;
int b = 4;
int c = 2;
int d = a + b * c;
Console.WriteLine(d);

De uitvoer laat zien dat vermenigvuldigen vóór optellen is uitgevoerd.

U kunt een andere bewerkingsvolgorde afdwingen door haakjes toe te voegen rond de bewerking of bewerkingen die u het eerst wilt uitvoeren. Voeg de volgende regels toe en voer opnieuw uit:

d = (a + b) * c;
Console.WriteLine(d);

Ontdek meer door veel verschillende bewerkingen te combineren. Voeg iets toe zoals de volgende regels. Probeer dotnet run opnieuw.

d = (a + b) - 6 * c + (12 * 4) / 3 + 12;
Console.WriteLine(d);

Er is u misschien al bijzonder gedrag opgevallen ten aanzien van gehele getallen. Het delen van gehele getallen levert altijd een resultaat met een geheel getal op, zelfs wanneer u zou verwachten dat het resultaat een decimaal of een breuk zou bevatten.

Als u dit gedrag niet hebt gezien, probeert u de volgende code:

int e = 7;
int f = 4;
int g = 3;
int h = (e + f) / g;
Console.WriteLine(h);

Typ dotnet run opnieuw om de resultaten weer te geven.

Voordat u verdergaat, nemen we alle code die u in deze sectie hebt geschreven en plaatsen we deze in een nieuwe methode. Roep die nieuwe methode aan OrderPrecedence. Uw code moet er ongeveer als volgt uitzien:

// WorkWithIntegers();
OrderPrecedence();

void WorkWithIntegers()
{
    int a = 18;
    int b = 6;
    int c = a + b;
    Console.WriteLine(c);


    // subtraction
    c = a - b;
    Console.WriteLine(c);

    // multiplication
    c = a * b;
    Console.WriteLine(c);

    // division
    c = a / b;
    Console.WriteLine(c);
}

void OrderPrecedence()
{
    int a = 5;
    int b = 4;
    int c = 2;
    int d = a + b * c;
    Console.WriteLine(d);

    d = (a + b) * c;
    Console.WriteLine(d);

    d = (a + b) - 6 * c + (12 * 4) / 3 + 12;
    Console.WriteLine(d);

    int e = 7;
    int f = 4;
    int g = 3;
    int h = (e + f) / g;
    Console.WriteLine(h);
}

De precisie en beperkingen van gehele getallen ontdekken

In het laatste voorbeeld hebt u gezien dat met het delen van gehele getallen het resultaat wordt afgekapt. U kunt de rest ophalen met behulp van de modulo-operator , het % teken. Probeer de volgende code na het aanroepen van de methode naar OrderPrecedence():

int a = 7;
int b = 4;
int c = 3;
int d = (a + b) / c;
int e = (a + b) % c;
Console.WriteLine($"quotient: {d}");
Console.WriteLine($"remainder: {e}");

Het soort geheel getal in C# verschilt op nog een ander vlak van de wiskundige gehele getallen: het type int heeft minimum- en maximumlimieten. Voeg deze code toe om deze limieten weer te geven:

int max = int.MaxValue;
int min = int.MinValue;
Console.WriteLine($"The range of integers is {min} to {max}");

Als een berekening een waarde oplevert die deze limieten overschrijdt, hebt u een negatieve overloop- of overloop-situatie. Het antwoord lijkt alles van de ene naar de andere limiet te omvatten. Voeg deze twee regels toe om een voorbeeld te zien:

int what = max + 3;
Console.WriteLine($"An example of overflow: {what}");

U ziet dat het antwoord erg dicht bij het minimale (negatieve) gehele getal ligt. Het staat gelijk aan min + 2. De optelbewerking heeft de toegestane waarden voor gehele getallen overschreden. Het antwoord is een erg groot negatief getal, omdat een overloop alles omvat van het hoogst mogelijke tot het laagst mogelijke gehele getal.

Er zijn andere numerieke soorten met afwijkende limieten en precisie, die u zou kunnen gebruiken in het geval dat het type int niet aan uw behoeften voldoet. Laten we deze andere typen nu eens bekijken. Voordat u begint met de volgende sectie, verplaatst u de code die u in deze sectie hebt geschreven naar een afzonderlijke methode. Noem deze TestLimits.

Werken met het dubbele type

Het numerieke type double geeft een drijvendekommagetal met dubbele precisie weer. Misschien bent u onbekend met deze termen. Een drijvendekommagetal is nuttig, omdat dit niet-gehele getallen weergeeft die qua magnitude zeer groot of zeer klein zijn. Dubbele precisie is een relatieve term die het aantal binaire cijfers beschrijft dat wordt gebruikt om de waarde op te slaan. Dubbele precisienummers hebben twee keer zoveel binaire cijfers als één precisie. Op moderne computers is het gebruikelijker om dubbele precisie te gebruiken dan enkelvoudige precisienummers. Getallen met één precisie worden gedeclareerd met behulp van het float trefwoord. Laten we dit nader bekijken. Voeg de volgende code toe en bekijk het resultaat:

double a = 5;
double b = 4;
double c = 2;
double d = (a + b) / c;
Console.WriteLine(d);

U ziet dat het antwoord het decimale gedeelte van het quotiënt bevat. Voer ook eens een iets gecompliceerdere expressie met dubbele cijfers in:

double e = 19;
double f = 23;
double g = 8;
double h = (e + f) / g;
Console.WriteLine(h);

Het bereik van een dubbele waarde is veel groter dan de waarden van gehele getallen. Probeer de volgende code onder wat u tot nu toe hebt geschreven:

double max = double.MaxValue;
double min = double.MinValue;
Console.WriteLine($"The range of double is {min} to {max}");

Deze waarden worden afgedrukt in wetenschappelijke notatie. Het getal links van de E is de significant. Het getal rechts is de exponent, als macht van 10. Dubbele cijfers in C# kunnen, net als bij decimale getallen in wiskunde, afrondfouten vertonen. Probeer deze code:

double third = 1.0 / 3.0;
Console.WriteLine(third);

U weet dat 0.3 het herhalen van een eindig aantal keren niet precies hetzelfde is als 1/3.

Uitdaging

Probeer andere berekeningen met grote getallen, kleine getallen, vermenigvuldigen en delen met behulp van het double type. Probeer meer gecompliceerde berekeningen. Nadat u enige tijd aan de uitdaging hebt besteed, neemt u de code die u hebt geschreven en plaatst u deze in een nieuwe methode. Geef die nieuwe methode WorkWithDoublesde naam .

Werken met decimale typen

U hebt de elementaire numerieke typen gezien in C#: gehele getallen en dubbele cijfers. Er is nog een ander type om te leren: het decimal type. Het type decimal heeft een geringer bereik, maar een grotere precisie dan double. Laten we eens een kijkje nemen:

decimal min = decimal.MinValue;
decimal max = decimal.MaxValue;
Console.WriteLine($"The range of the decimal type is {min} to {max}");

U ziet dat het bereik geringer is dan die van het type double. U ziet de grotere precisie van het decimale type zien als u de volgende code invoert:

double a = 1.0;
double b = 3.0;
Console.WriteLine(a / b);

decimal c = 1.0M;
decimal d = 3.0M;
Console.WriteLine(c / d);

Met het achtervoegsel M bij de getallen geeft u aan dat een constante het type decimal behoort te gebruiken. Anders gaat de compiler uit van het double type.

Notitie

De letter M is gekozen als de meest visuele letter tussen de double trefwoorden en decimal .

U ziet dat de rekensom die gebruikmaakt van het decimale type over meer decimalen aan de rechterkant van de decimale komma beschikt.

Uitdaging

Schrijf, nu u de verschillende numerieke typen hebt gezien, code waarmee het oppervlak van een cirkel wordt berekend waarvan de straal 2,5 cm is. Denk eraan dat het oppervlak van een cirkel wordt bepaald door de straal in het kwadraat vermenigvuldigd met pi. Een hint: .NET bevat een constante voor PI, Math.PI, die u kunt gebruiken voor die waarde. Math.PI, zoals alle constanten die in de System.Math naamruimte zijn gedeclareerd, een double waarde is. Daarom moet u in plaats van decimal waarden gebruiken double voor deze uitdaging.

U zou een antwoord moeten krijgen tussen 19 en 20. U kunt uw antwoord controleren door de voltooide voorbeeldcode op GitHub te bekijken.

Probeer ook eens enkele andere formules.

U hebt de quickstart 'Getallen in C#' voltooid. U kunt doorgaan met de quickstart Vertakkingen en lussen in uw eigen ontwikkelomgeving.

Meer informatie over getallen in C# vindt u in de volgende artikelen: