Zelfstudie: Integer- en drijvende-kommanummers gebruiken in C#

In deze handleiding leer je over de numerieke typen in C#. U schrijft kleine hoeveelheden code, vervolgens compileert en voert u die code uit. De zelfstudie bevat een reeks lessen waarmee getallen en wiskundige bewerkingen in C# worden verkend. In deze lessen leert u de basisprincipes van de C#-taal.

In deze handleiding leert u:

Vereiste voorwaarden

U moet een van de volgende opties hebben:

• Een GitHub-account voor het gebruik van GitHub Codespaces. Als u nog geen account hebt, kunt u een gratis account maken op GitHub.com.
• Een computer waarop de volgende hulpprogramma's zijn geïnstalleerd:
  • De .NET 10 SDK.
  • Visual Studio Code.
  • De C# DevKit.

Berekening van gehele getallen verkennen

Als u een GitHub Codespace met de zelfstudieomgeving wilt starten, opent u een browservenster naar de opslagplaats van de zelfstudiecodespace . Selecteer de groene knop Code en het tabblad Codespaces . Selecteer vervolgens het + teken om een nieuwe Codespace te maken met behulp van deze omgeving. Als u de hallo wereld-zelfstudie hebt voltooid, kunt u die coderuimte openen in plaats van een nieuwe te maken.

1. Wanneer uw codespace wordt geladen, maakt u een nieuw bestand in de map zelfstudies met de naam numbers.cs.

2. Open het nieuwe bestand.

3. Typ of kopieer de volgende code in numbers.cs:

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

4. Voer deze code uit door de volgende opdrachten in de geïntegreerde terminal te typen:

   cd ./tutorials
   dotnet numbers.cs
   

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

   • - voor aftrekken
   • * voor vermenigvuldigen
   • / voor divisie

5. Begin met het verkennen van deze verschillende bewerkingen. Voeg deze regels toe na de regel waarmee de waarde van c:

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

6. Voer deze code uit door in het terminalvenster te typen dotnet numbers.cs .

U kunt ook experimenteren door meerdere wiskundige bewerkingen in dezelfde regel te schrijven, als u dat wilt. Probeer c = a + b - 12 * 17; bijvoorbeeld. Het combineren van variabelen en constante getallen is toegestaan.

U hebt de eerste stap voltooid. Voordat u de volgende sectie start, gaan we de huidige code naar een afzonderlijke methode verplaatsen. Een methode is een reeks instructies die gegroepeerd zijn en een naam hebben gekregen. 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 volgorde van bewerkingen verkennen

1. Zet de oproep naar WorkingWithIntegers() in commentaar. Hierdoor wordt de uitvoer minder rommelig als u in deze sectie werkt:

   //WorkWithIntegers();
   

   Een // wordt gestart met in C#. Opmerkingen zijn tekst die u in de broncode wilt bewaren, maar niet als code wilt uitvoeren. De compiler genereert geen uitvoerbare code uit opmerkingen. Omdat WorkWithIntegers() dit een methode is, moet u slechts één regel uitcommentariëren.

2. De C#-taal definieert de prioriteit van verschillende wiskundige bewerkingen met regels die consistent zijn met de regels die u in wiskunde hebt geleerd. Vermenigvuldigen en delen hebben voorrang op optellen en aftrekken. Verken dit door de volgende code toe te voegen na de aanroep naar WorkWithIntegers()en te typen dotnet numbers.cs in het terminalvenster:

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

   De uitvoer laat zien dat de vermenigvuldiging vóór de toevoeging wordt uitgevoerd.

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

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

4. Verken meer door veel verschillende bewerkingen te combineren. Voeg iets toe zoals de volgende regels. Probeer dotnet numbers opnieuw in het terminalvenster.

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

   Mogelijk ziet u een interessant gedrag voor gehele getallen. Deling van gehele getallen produceert altijd een geheel getal, zelfs wanneer u verwacht dat het resultaat een decimaal of breukdeel bevat.

5. 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);
   

6. Typ dotnet numbers.cs opnieuw in het terminalvenster om de resultaten te bekijken.

Voordat we verdergaan, laten we alle code die je in deze sectie hebt geschreven in een nieuwe methode plaatsen. Roep die nieuwe methode OrderPrecedenceaan. 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 limieten van gehele getallen verkennen

In het vorige voorbeeld is gebleken dat de verdeling van gehele getallen het resultaat afkapt. U kunt de rest ophalen met behulp van de restoperator , het % teken.

1. Probeer de volgende code na de methodeaanroep 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}");
   

2. Het type C#-geheel getal verschilt van wiskundige gehele getallen op een andere manier: het int type heeft minimum- en maximumlimieten. Probeer de volgende code om deze limieten te zien:

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

3. Als een berekening een waarde produceert die deze limieten overschrijdt, hebt u een onderloop- of overloopvoorwaarde. Het antwoord lijkt van de ene limiet naar de andere te overspringen. Als u een voorbeeld wilt zien, voegt u deze twee regels toe aan uw code:

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

U ziet dat het antwoord zeer dicht bij het minimale (negatieve) gehele getal ligt. Het is hetzelfde als min + 2. De optelling veroorzaakte een overschrijding van de toegestane waarden voor gehele getallen. Het antwoord is een groot negatief getal omdat een overloop 'rondloopt' van de grootst mogelijke gehele waarde naar de kleinste waarde.

Er zijn andere numerieke typen met verschillende limieten en precisie die u kunt gebruiken wanneer het int type niet aan uw behoeften voldoet. Laten we deze typen getallen eens bekijken.

Werken met het dubbel datatype

Het double numerieke type vertegenwoordigt een drijvendekommagetal met dubbele precisie. Deze termen zijn mogelijk nieuw voor u. Een drijvendekommagetal is handig voor het weergeven van niet-integrale getallen die zeer groot of klein kunnen zijn. dubbele precisie is een relatieve term die het aantal binaire cijfers beschrijft dat wordt gebruikt om de waarde op te slaan. Dubbele-precisie getallen hebben twee keer zoveel binaire cijfers als enkelvoudige-precisie. Op moderne computers gebruikt u vaker dubbele precisie dan enkele precisienummers. Enkelvoudige precisienummers worden gedeclareerd met behulp van het float trefwoord. Laten we eens kijken.

1. 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 decimaal gedeelte van het quotiënt bevat.

2. Probeer een iets gecompliceerdere uitdrukking met dubbels. U kunt de volgende waarden gebruiken of andere getallen vervangen:

   double a = 19;
   double b = 23;
   double c = 8;
   double d = (a + b) / c;
   Console.WriteLine(d);
   

3. Het bereik van een dubbele waarde is veel groter dan gehele getallen. Probeer de volgende code die u toevoegt aan 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 het E getal is het tekenteken. Het getal rechts is de exponent, als macht van 10.

4. Net als decimale getallen in wiskunde kunnen dubbele getallen in C# afrondingsfouten hebben. Probeer deze code:

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

   U weet dat 0.33/10 is en niet precies hetzelfde is als 1/3. Op dezelfde manier is 0.3333/100. Die waarde is dichter bij 1/3, maar nog steeds niet exact. Ongeacht het aantal decimalen dat u toevoegt, blijft er een afrondingsfout over.

Uitdaging

Probeer andere berekeningen met grote getallen, kleine getallen, vermenigvuldiging en deling met behulp van het double type. Probeer complexere berekeningen uit te voeren. Nadat u wat tijd hebt besteed aan de uitdaging, neemt u de code die u hebt geschreven en plaatst u deze in een nieuwe methode. Geef die nieuwe methode WorkWithDoubleseen naam.

Werken met decimale typen

U hebt de eenvoudige numerieke typen in C#: gehele getallen en dubbele getallen gezien. Er is nog een ander type om te leren: het decimal type. Het decimal type heeft een kleiner bereik, maar een grotere precisie dan double.

1. Laten we eens kijken:

   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 kleiner is dan het double type.

2. U kunt de grotere precisie met het decimale type zien door de volgende code uit te voeren:

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

   U ziet dat de wiskunde met het decimale type meer cijfers rechts van het decimaalteken heeft.

   Het M achtervoegsel op de getallen geeft aan dat een constante het decimal type moet gebruiken. Anders wordt door de compiler uitgegaan van het double type.

Uitdaging

Nu u de verschillende numerieke typen kent, schrijft u code waarmee het gebied van een cirkel wordt berekend waarvan de straal 2,50 centimeter is. Houd er rekening mee dat de oppervlakte van een cirkel de straal in het kwadraat is vermenigvuldigd met PI. Een hint: .NET bevat een constante voor PI, Math.PI die u voor die waarde kunt gebruiken. Math.PI, zoals alle constanten die zijn gedeclareerd in de System.Math naamruimte, een double waarde is. Daarom moet u double gebruiken in plaats van decimal waarden voor deze uitdaging.

U moet een antwoord krijgen tussen 19 en 20.

double radius = 2.50;
double area = Math.PI * radius * radius;
Console.WriteLine(area);

Probeer desgewenst andere formules.

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

• Integrale numerieke typen
• zwevendekommagetaltypen
• ingebouwde numerieke conversies

Middelen opschonen

GitHub verwijdert uw Codespace automatisch na 30 dagen inactiviteit. Als u van plan bent om meer tutorials uit deze serie te volgen, kunt u uw Codespace geconfigureerd laten. Als u klaar bent om naar de .NET-site te gaan om de .NET SDK te downloaden, kunt u uw Codespace verwijderen. Als u uw Codespace wilt verwijderen, opent u een browservenster en gaat u naar uw Codespaces. U ziet nu een lijst met uw coderuimten in het venster. Selecteer de drie puntjes (...) in de vermelding voor de zelfstudiecoderuimte en selecteer Verwijderen.

Volgende stap