Dela via


Använda heltal och flyttalsnummer i C#

I den här handledningen lär du dig om de numeriska typerna i C#. Du skriver små mängder kod och kompilerar och kör sedan koden. Handledningen innehåller en serie lektioner som utforskar siffror och matematiska operationer i C#. De här lektionerna lär dig grunderna i C#-språket.

Tips

När ett kodfragmentblock innehåller knappen "Kör" öppnas det interaktiva fönstret eller ersätter den befintliga koden i det interaktiva fönstret. När kodfragmentet inte innehåller någon "Kör"-knapp kan du kopiera koden och lägga till den i det aktuella interaktiva fönstret.

Utforska heltalsmatematik

Kör följande kod i det interaktiva fönstret.

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

Föregående kod visar grundläggande matematiska åtgärder med heltal. Den int typen representerar ett heltal, ett positivt eller negativt heltal. Du använder symbolen + för addition. Andra vanliga matematiska åtgärder för heltal är:

  • - för subtraktion
  • * för multiplikation
  • / för division

Börja med att utforska de olika åtgärderna. Ändra den tredje raden för att prova var och en av dessa åtgärder. Om du till exempel vill prova subtraktion ersätter du + med en - enligt följande rad:

int c = a - b;

Prova. Välj knappen "Kör". Prova sedan multiplikation, * och division, /. Du kan också experimentera genom att skriva flera matematikåtgärder på samma rad, om du vill.

Tips

När du utforskar C# (eller något programmeringsspråk) gör du misstag när du skriver kod. -kompilatorn hittar dessa fel och rapporterar dem till dig. När utdata innehåller felmeddelanden bör du titta närmare på exempelkoden och koden i det interaktiva fönstret för att se vad som ska åtgärdas. Den här övningen hjälper dig att lära dig strukturen för C#-kod.

Utforska driftordningen

C#-språket definierar prioriteten för olika matematikåtgärder med regler som överensstämmer med de regler som du har lärt dig i matematik. Multiplikation och division har företräde framför addition och subtraktion. Utforska det genom att köra följande kod i det interaktiva fönstret:

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

Utdata visar att multiplikationen utförs före tillägget.

Du kan framtvinga en annan åtgärdsordning genom att lägga till parenteser runt den åtgärd eller de åtgärder som du vill utföra först. Lägg till följande rader i det interaktiva fönstret:

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

Utforska mer genom att kombinera många olika åtgärder. Ersätt den fjärde raden i föregående kod med något liknande:

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

Du kanske märker ett intressant beteende för heltal. Heltalsdivisionen ger alltid ett heltalsresultat, även om du förväntar dig att resultatet ska innehålla en decimal- eller bråkdel.

Prova följande kod:

int a = 7;
int b = 4;
int c = 3;
int d = (a + b) / c;
Console.WriteLine(d);

Utforska heltalsprecision och gränser

Det senaste exemplet visade att heltalsdivisionen trunkerar resultatet. Du kan hämta rest med hjälp av operatorn rest%:

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}");

Heltalstypen C# skiljer sig från matematiska heltal på ett annat sätt: den int typen har minimi- och maxgränser. Prova följande kod för att se dessa gränser:

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

Om en beräkning genererar ett värde som överskrider dessa gränser har du ett underflöde eller överflöde situation. Svaret sträcker sig från den ena gränsen till den andra. Om du vill se ett exempel lägger du till dessa två rader i det interaktiva fönstret:

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

Observera att svaret ligger mycket nära det minsta (negativa) heltalet. Det är samma som min + 2. Adderingsoperationen överskred de tillåtna värdena för heltal. Svaret är ett stort negativt tal eftersom ett överflöde "slår runt" från det största möjliga heltalsvärdet till det minsta.

Det finns andra numeriska typer med olika gränser och precision som du använder när den int typen inte uppfyller dina behov. Nu ska vi utforska de här typerna av siffror.

Arbeta med dubbeltypen

Den double numeriska typen representerar ett flyttal med dubbel precision. Dessa villkor kan vara nya för dig. En flyttalsnummer är användbar för att representera icke-integrerade tal som kan vara stora eller små i magnitud. Dubbelprecision är en relativ term som beskriver antalet binära siffror som används för att lagra värdet. Dubbel precision tal har dubbelt så många binära siffror som . På moderna datorer är det vanligare att använda dubbel precision än enkla precisionsnummer. Tal med enkel precision deklareras med nyckelordet float. Nu ska vi utforska. Kör följande kod och se resultatet:

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

Observera att svaret innehåller decimaldelen av kvoten. Prova ett något mer komplicerat uttryck med dubblar. Du kan använda följande värden eller ersätta andra tal:

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

Intervallet för ett dubbelt värde är större än heltalsvärden. Prova följande kod i det interaktiva fönstret:

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

Dessa värden skrivs ut i vetenskaplig notation. Talet före E är significand. Talet efter E är exponenten, som en tiopotens.

Precis som decimaltal i matematik kan dubbla i C# ha avrundningsfel. Prova den här koden:

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

Du vet att 0.3 är 3/10 och inte exakt samma som 1/3. På samma sätt är 0.3333/100. Det värdet är närmare 1/3, men ändå inte exakt. Oavsett hur många decimaler du lägger till kvarstår ett avrundningsfel.

Utmaning

Prova andra beräkningar med stora tal, små tal, multiplikation och division med hjälp av double typ. Prova mer komplicerade beräkningar.

Arbeta med decimaltyper

Det finns en annan typ att lära sig: decimal-typen. Den decimal typen har ett mindre intervall men större precision än double. Låt oss ta en titt:

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

Observera att intervallet är mindre än den double typen. Du kan se större precision med decimaltypen genom att prova följande kod:

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

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

Observera att matematiken som använder decimaltypen har fler siffror till höger om decimaltecknet.

Det M-suffixet på siffrorna är hur du indikerar att en konstant ska använda typen decimal. I annat fall förutsätter kompilatorn double typ.

Anteckning

Bokstaven M valdes som den mest visuellt distinkta bokstaven mellan nyckelorden double och decimal.

Utmaning

Skriv kod som beräknar området för en cirkel vars radie är 2,50 centimeter. Kom ihåg att området i en cirkel är radien i kvadrat multiplicerat med PI. Ett tips: .NET innehåller en konstant för PI, Math.PI som du kan använda för det värdet. Math.PI, precis som alla konstanter som deklarerats i System.Math namnområdet, är ett double värde. Därför bör du använda double i stället för decimal värden för den här utmaningen.

Du bör få ett svar mellan 19 och 20.

När du har provat det öppnar du informationsfönstret för att se hur du gjorde:

:::code language="csharp" interactive="try-dotnet-method" source="./snippets/NumbersInCsharp/Program.cs" id="Challenge":::

Prova några andra formler om du vill.

Du har slutfört den interaktiva självstudien "Numbers in C#". Du kan välja länken Grenar och loopar för att starta nästa interaktiva självstudie, eller så kan du gå till .NET-webbplats för att ladda ned .NET SDK, skapa ett projekt på datorn och fortsätta koda. Avsnittet "Nästa steg" tar dig tillbaka till de här självstudierna.

Du kan lära dig mer om tal i C# i följande artiklar: