Övning – Utföra matematiska åtgärder

  • 10 minuter

Nu när du förstår grunderna i addition och ännu viktigare, implicit typkonvertering mellan numeriska datatyper och strängdatatyper, ska vi titta på flera andra vanliga matematiska åtgärder på numeriska data.

Utföra grundläggande matematiska åtgärder

Skriva kod för att utföra addition, subtraktion, multiplikation och division med heltal

  1. Markera all kod i .NET-redigeraren och tryck på Ta bort eller Backspace för att ta bort den.

  2. Ange följande kod i .NET-redigeraren:

    int sum = 7 + 5;
int difference = 7 - 5;
int product = 7 * 5;
int quotient = 7 / 5;

Console.WriteLine("Sum: " + sum);
Console.WriteLine("Difference: " + difference);
Console.WriteLine("Product: " + product);
Console.WriteLine("Quotient: " + quotient);

  3. Kör koden. Du bör se följande utdata:

    Sum: 12
Difference: 2
Product: 35
Quotient: 1

Observera följande:

  • + är additionsoperatorn
  • - är subtraktionsoperatorn
  • * är multiplikationsoperatorn
  • / är divisionsoperatorn

Den resulterande kvoten i divisionsexemplet kanske inte är vad du kan ha förväntat dig. Värdena efter decimaltecknet trunkeras från quotient eftersom det definieras som en int, och int kan inte innehålla värden efter decimaltecknet.

Lägg till kod för att utföra division med hjälp av literala decimaldata

Om du vill se att divisionen fungerar korrekt måste du använda en datatyp som stöder bråktalssiffror efter decimaltecknet som decimal.

  1. Ta bort koden från föregående steg och ange följande kod i .NET-redigeraren:

    decimal decimalQuotient = 7.0m / 5;
Console.WriteLine($"Decimal quotient: {decimalQuotient}");

  2. Kör koden. Du bör se följande utdata:

    Decimal quotient: 1.4

För att detta ska fungera måste kvoten (till vänster om tilldelningsoperatorn) vara av typen decimal och minst ett av talen som delas måste också vara av typen decimal (båda talen kan också vara en decimal typ).

Här är två exempel till som fungerar lika bra:

decimal decimalQuotient = 7 / 5.0m;
decimal decimalQuotient = 7.0m / 5.0m;

De här kodraderna skulle däremot inte fungera (eller så skulle det ge ett felaktigt resultat):

int decimalQuotient = 7 / 5.0m;
int decimalQuotient = 7.0m / 5;
int decimalQuotient = 7.0m / 5.0m;
decimal decimalQuotient = 7 / 5;

Lägga till kod för att omvandla resultat från heltalsdivision

Hur ska du göra om du inte jobbar med literalvärden? Du kanske har två variabler av typen int men inte vill att resultatet ska trunkeras. I så fall måste du typkonvertera från int till decimal. Med typkonvertering säger du åt kompilatorn att temporärt behandla ett värde som om datatypen var en annan.

Om du vill typkonvertera int till decimal lägger du till konverteringsoperatorn före värdet. Du använder namnet på datatypen omgiven av parenteser framför värdet för att omvandla den. I det här fallet lägger du till (decimal) före variablerna first och second.

  1. Ta bort koden från föregående steg och ange följande kod i .NET-redigeraren:

    int first = 7;
int second = 5;
decimal quotient = (decimal)first / (decimal)second;
Console.WriteLine(quotient);

  2. Kör koden. Du bör se följande utdata:

    1.4

Kommentar

Du har sett tre användningsområden för parentesoperatorn: metodanrop, åtgärdsordning och gjutning.

Skriv kod för att fastställa resten efter heltalsdivisionen

Modulusoperatorn % anger resten av int divisionen. Det du egentligen tar reda på här är om ett tal är delbart med ett annat. Det kan vara användbart under långa bearbetningsåtgärder där du går igenom hundratals eller tusentals dataposter och vill ge återkoppling till slutanvändaren efter varje block om 100 dataposter.

  1. Ta bort koden från föregående steg och ange följande kod i .NET-redigeraren:

    Console.WriteLine($"Modulus of 200 / 5 : {200 % 5}");
Console.WriteLine($"Modulus of 7 / 5 : {7 % 5}");

  2. Kör koden. Du bör se följande utdata:

    Modulus of 200 / 5 : 0
Modulus of 7 / 5 : 2

När resten är 0 innebär det att täljaren är delbar med nämnaren.

Ordning på åtgärder

Som du lärde dig i föregående övning kan du använda symbolerna () som åtgärdsoperatorernas ordning. Det är däremot inte det enda sätt som används till att ange ordningen.

I matematik är PEMDAS en förkortning som hjälper eleverna att komma ihåg driftordningen. Ordningen är:

  1. Parenteser (det som står inom parentes utförs först)
  2. Exponenter
  3. Multiplikation och Division (från vänster till höger)
  4. Addition och Subtraktion (från vänster till höger)

C# följer samma ordning som i PEMDAS förutom för exponenter. Även om det inte finns någon exponentoperator i C#, kan du använda System.Math.Pow metoden. I modulen ”Anropa metoder från .NET-klassbiblioteket med hjälp av C#” använder du både den här och andra metoder.

Skriva kod för att träna C#:s driftordning

  1. Ta bort koden från föregående steg och ange följande kod i .NET-redigeraren:

    int value1 = 3 + 4 * 5;
int value2 = (3 + 4) * 5;
Console.WriteLine(value1);
Console.WriteLine(value2);

    Här ser du skillnaden när du utför samma åtgärder i en annan ordning.

  2. Kör koden. Du bör se följande utdata:

    23
35

Sammanfattning

Här är vad du har lärt dig hittills om matematiska operationer i C#:

  • Använd operatorer som +, -, * och / till att utföra grundläggande matematiska operationer.
  • Division av två int-värden gör att delen efter decimaltecknet trunkeras. Om du vill behålla värden efter decimaltecknet måste du omvandla divisorn eller utdelningen (eller båda) från int till ett flyttalsnummer som decimal först, då måste kvoten också vara av samma flyttaltyp för att undvika trunkering.
  • Utför en typkonvertering för att temporärt behandla ett värde som om datatypen var en annan.
  • Använd operatorn % till att ta fram resten efter division.
  • Ordningen på operationerna följer reglerna i förkortningen PEMDAS.