Operator aritmetika (referensi C#)

Artikel
04/08/2023

Operator berikut melakukan operasi aritmetika dengan operand jenis numerik:

Operator tunggal++ (kenaikan), -- (penurunan), + (plus), dan - (minus)
Operator Biner * (perkalian), / (pembagian), % (sisa), + (tambahan), dan - (pengurangan)

Operator tersebut didukung oleh semua jenis numerik integral dan floating-point.

Dalam kasus jenis integral, operator tersebut (kecuali operator ++ dan --) didefinisikan untuk jenis int, uint, long, dan ulong. Ketika kedua operand adalah dari jenis integral lainnya (sbyte, byte, short, ushort, atau char), nilainya dikonversi ke jenis int, yang juga merupakan jenis hasil operasi. Ketika operand memiliki jenis integral atau titik mengambang yang berbeda, nilainya dikonversi ke jenis penampung terdekat, jika jenis tersebut ada. Untuk informasi selengkapnya, lihat bagian Promosi numerik dari spesifikasi bahasa C#. Operator ++ dan -- didefinisikan untuk semua jenis numerik integral dan titik mengambang dan jenis char. Jenis hasil ekspresi penetapan majemuk adalah jenis operand sebelah kiri.

Operator kenaikan ++

Operator kenaikan tunggal ++ menaikkan operand-nya sebesar 1. Operand harus berupa variabel, akses properti, atau akses pengindeks.

Operator kenaikan didukung dalam dua bentuk: operator kenaikan postfiks, x++, dan operator kenaikan prefiks, ++x.

Operator kenaikan postfiks

Hasil x++ adalah nilai xsebelum operasi, seperti yang ditunjukkan contoh berikut:

int i = 3;
Console.WriteLine(i);   // output: 3
Console.WriteLine(i++); // output: 3
Console.WriteLine(i);   // output: 4

Operator kenaikan prefiks

Hasil ++x adalah nilai xsetelah operasi, seperti yang ditunjukkan contoh berikut:

double a = 1.5;
Console.WriteLine(a);   // output: 1.5
Console.WriteLine(++a); // output: 2.5
Console.WriteLine(a);   // output: 2.5

Operator pengurangan --

Operator pengurangan tunggal -- mengurangi operand-nya sebesar 1. Operand harus berupa variabel, akses properti, atau akses pengindeks.

Operator kenaikan didukung dalam dua bentuk: operator kenaikan postfiks, x--, dan operator kenaikan prefiks, --x.

Operator penurunan postfiks

Hasil x-- adalah nilai xsebelum operasi, seperti yang ditunjukkan contoh berikut:

int i = 3;
Console.WriteLine(i);   // output: 3
Console.WriteLine(i--); // output: 3
Console.WriteLine(i);   // output: 2

Operator penurunan prefiks

Hasil --x adalah nilai xsetelah operasi, seperti yang ditunjukkan contoh berikut:

double a = 1.5;
Console.WriteLine(a);   // output: 1.5
Console.WriteLine(--a); // output: 0.5
Console.WriteLine(a);   // output: 0.5

Operator plus dan minus tunggal

Operator + tunggal mengembalikan nilai operand-nya. Operator - tunggal menghitung negasi numerik operand-nya.

Console.WriteLine(+4);     // output: 4

Console.WriteLine(-4);     // output: -4
Console.WriteLine(-(-4));  // output: 4

uint a = 5;
var b = -a;
Console.WriteLine(b);            // output: -5
Console.WriteLine(b.GetType());  // output: System.Int64

Console.WriteLine(-double.NaN);  // output: NaN

Jenis ulong tidak mendukung operator - tunggal.

operasi perkalian *

Operator perkalian * menghitung produk operandnya:

Console.WriteLine(5 * 2);         // output: 10
Console.WriteLine(0.5 * 2.5);     // output: 1.25
Console.WriteLine(0.1m * 23.4m);  // output: 2.34

Operator * tunggal adalah operator tidak langsung pointer.

operator pembagian /

Operator divisi / membagi operand sebelah kirinya dengan operand kanannya.

Pembagian bilangan bulat

Untuk operand jenis bilangan bulat, hasil operator / adalah dari jenis bilangan bulat dan sama dengan hasil bagi dari dua operand yang dibulatkan menuju nol:

Console.WriteLine(13 / 5);    // output: 2
Console.WriteLine(-13 / 5);   // output: -2
Console.WriteLine(13 / -5);   // output: -2
Console.WriteLine(-13 / -5);  // output: 2

Untuk mendapatkan hasil bagi dari dua operand sebagai angka titik mengambang, gunakan jenis float, double, atau decimal:

Console.WriteLine(13 / 5.0);       // output: 2.6

int a = 13;
int b = 5;
Console.WriteLine((double)a / b);  // output: 2.6

Pembagian titik mengambang

Untuk jenis float, double, dan decimal, hasil dari operator / adalah hasil bagi dari dua operand:

Console.WriteLine(16.8f / 4.1f);   // output: 4.097561
Console.WriteLine(16.8d / 4.1d);   // output: 4.09756097560976
Console.WriteLine(16.8m / 4.1m);   // output: 4.0975609756097560975609756098

Jika salah satu operand adalah decimal, operand lain tidak dapat float atau double, karena baik float maupun double tidak dapat diubah secara implisit menjadi decimal. Anda harus secara eksplisit mengonversi operand float atau double ke jenis decimal. Untuk informasi selengkapnya tentang konversi antar jenis numerik, lihat Konversi numerik bawaan.

Operator sisa %

Operator % yang tersisa menghitung sisanya setelah membandingkan operand kirinya dengan operand kanannya.

Sisa bilangan bulat

Untuk operand jenis bilangan bulat, hasil a % b adalah nilai yang dihasilkan oleh a - (a / b) * b. Tanda sisa bukan nol sama dengan operand sebelah kiri, seperti yang ditunjukkan contoh berikut:

Console.WriteLine(5 % 4);   // output: 1
Console.WriteLine(5 % -4);  // output: 1
Console.WriteLine(-5 % 4);  // output: -1
Console.WriteLine(-5 % -4); // output: -1

Gunakan metode Math.DivRem untuk menghitung pembagian bilangan bulat dan hasil yang tersisa.

Sisa titik mengambang

Untuk operand float dan double, hasil dari x % y untuk x dan y terbatas merupakan nilai z

Tanda z, jika bukan nol, sama dengan tanda x.
Nilai absolut z adalah nilai yang dihasilkan oleh |x| - n * |y| di mana n adalah bilangan bulat terbesar yang mungkin kurang dari atau sama dengan |x| / |y| dan |x|, selain itu |y| masing-masing adalah nilai absolut x dan y.

Catatan

Metode komputasi sisa ini dianalogikan dengan yang digunakan untuk operand bilangan bulat, tetapi berbeda dari spesifikasi IEEE 754. Jika Anda memerlukan operasi sisa yang sesuai dengan spesifikasi IEEE 754, gunakan metode Math.IEEERemainder.

Untuk informasi tentang perilaku operator % dengan operand yang bukan terbatas, lihat bagian Operator sisa dari spesifikasi bahasa C#.

Untuk operand decimal, operator % sisanya setara dengan operator sisa jenisSystem.Decimal.

Contoh berikut menunjukkan perilaku operator sisa dengan operand titik mengambang:

Console.WriteLine(-5.2f % 2.0f); // output: -1.2
Console.WriteLine(5.9 % 3.1);    // output: 2.8
Console.WriteLine(5.9m % 3.1m);  // output: 2.8

operator tambahan +

Operator tambahan + menghitung jumlah operandnya:

Console.WriteLine(5 + 4);       // output: 9
Console.WriteLine(5 + 4.3);     // output: 9.3
Console.WriteLine(5.1m + 4.2m); // output: 9.3

Anda juga dapat menggunakan operator + untuk kombinasi perangkaian string dan delegasi. Untuk informasi selengkapnya, lihat artikel + dan += operator.

operasi pengurangan -

Operator pengurangan - mengurangi operand sebelah kanannya dari operand sebelah kirinya:

Console.WriteLine(47 - 3);      // output: 44
Console.WriteLine(5 - 4.3);     // output: 0.7
Console.WriteLine(7.5m - 2.3m); // output: 5.2

Anda juga dapat menggunakan operator - untuk penghapusan delegasi. Untuk informasi selengkapnya, lihat artikel - dan -= operator.

Penetapan campuran

Untuk op operator biner, ekspresi penetapan campuran dari formulir

x op= y

setara dengan:

x = x op y

kecuali x hanya dievaluasi sekali.

Contoh berikut menunjukkan penggunaan penetapan campuran dengan operator aritmetika:

int a = 5;
a += 9;
Console.WriteLine(a);  // output: 14

a -= 4;
Console.WriteLine(a);  // output: 10

a *= 2;
Console.WriteLine(a);  // output: 20

a /= 4;
Console.WriteLine(a);  // output: 5

a %= 3;
Console.WriteLine(a);  // output: 2

Karena promosi numerik, hasil op operasi mungkin tidak secara implisit dapat dikonversi ke jenis T dari x. Dalam kasus seperti itu, jika op adalah operator yang telah ditentukan sebelumnya dan hasil operasi secara eksplisit dapat dikonversi ke jenis T dari x, ekspresi penetapan campuran formulir x op= y setara dengan x = (T)(x op y), kecuali x hanya dievaluasi sekali. Contoh berikut menunjukkan perilaku tersebut:

byte a = 200;
byte b = 100;

var c = a + b;
Console.WriteLine(c.GetType());  // output: System.Int32
Console.WriteLine(c);  // output: 300

a += b;
Console.WriteLine(a);  // output: 44

Dalam contoh sebelumnya, nilai 44 adalah hasil dari mengonversi nilai 300 ke byte jenis .

Catatan

Dalam konteks pemeriksaan luapan yang diperiksa, contoh sebelumnya melempar OverflowException. Untuk informasi selengkapnya, lihat bagian Luapan aritmatika bilangan bulat.

Anda juga menggunakan operator += dan -= untuk berlangganan dan berhenti berlangganan dari suatu acara. Untuk informasi selengkapnya, lihat Cara berlangganan dan berhenti berlangganan dari peristiwa.

Asosiasivitas dan prioritas operator

Daftar berikut mengurutkan operator aritmetika mulai dari prioritas tertinggi hingga terendah:

Operator kenaikan x++ dan penurunan postfiks x--
Prefiks kenaikan ++x dan penurunan --x serta tunggal + dan operator -
Operator multiplikatif *, /, dan %
Operator tambahan + dan -

Operator aritmetika biner bersifat asosiatif kiri. Artinya, operator dengan tingkat prioritas yang sama dievaluasi dari kiri ke kanan.

Gunakan tanda kurung, (), untuk mengubah urutan evaluasi yang diberlakukan oleh prioritas dan asosiasi operator.

Console.WriteLine(2 + 2 * 2);   // output: 6
Console.WriteLine((2 + 2) * 2); // output: 8

Console.WriteLine(9 / 5 / 2);   // output: 0
Console.WriteLine(9 / (5 / 2)); // output: 4

Untuk daftar lengkap operator C# yang diurutkan berdasarkan tingkat prioritas, lihat bagian Prioritas operator dari artikel operator C#.

Luapan aritmetika dan pembagian dengan nol

Ketika hasil operasi aritmetika berada di luar rentang kemungkinan nilai terbatas dari jenis numerik yang terlibat, perilaku operator aritmetika tergantung pada jenis operand-nya.

Luapan aritmetika bilangan bulat

Pembagian bilangan bulat dengan nol selalu melempar DivideByZeroException.

Jika terjadi luapan aritmatika bilangan bulat, konteks pemeriksaan luapan, yang dapat diperiksa atau tidak dicentang, mengontrol perilaku yang dihasilkan:

Dalam konteks yang diperiksa, jika luapan terjadi dalam ekspresi konstanta, kesalahan waktu kompilasi terjadi. Jika tidak, ketika operasi dilakukan pada durasi, OverflowException akan dilemparkan.
Dalam konteks yang tidak diperiksa, hasilnya dipotong dengan membuang bit berurutan tinggi yang tidak cocok dengan jenis tujuan.

Bersama dengan pernyataan yang dicentang dan tidak dicentang , Anda dapat menggunakan checked operator dan unchecked untuk mengontrol konteks pemeriksaan luapan, di mana ekspresi dievaluasi:

int a = int.MaxValue;
int b = 3;

Console.WriteLine(unchecked(a + b));  // output: -2147483646
try
{
    int d = checked(a + b);
}
catch(OverflowException)
{
    Console.WriteLine($"Overflow occurred when adding {a} to {b}.");
}

Secara default, operasi aritmetika terjadi dalam konteks yang tidak diperiksa.

Aritmetika Titik Mengambang

Operasi aritmetika dengan jenis float dan double tidak pernah melemparkan pengecualian. Hasil operasi aritmetika dengan jenis tersebut dapat menjadi salah satu nilai khusus yang mewakili tak terbatas dan bukan angka:

double a = 1.0 / 0.0;
Console.WriteLine(a);                    // output: Infinity
Console.WriteLine(double.IsInfinity(a)); // output: True

Console.WriteLine(double.MaxValue + double.MaxValue); // output: Infinity

double b = 0.0 / 0.0;
Console.WriteLine(b);                // output: NaN
Console.WriteLine(double.IsNaN(b));  // output: True

Untuk operand jenis decimal, luapan aritmetika selalu melempar OverflowException. Pembagian dengan nol selalu melempar DivideByZeroException.

Kesalahan round-off

Karena keterbatasan umum representasi titik mengambang dari bilangan riil dan aritmetika titik mengambang, kesalahan round-off mungkin terjadi dalam perhitungan dengan jenis titik mengambang. Artinya, hasil ekspresi yang dihasilkan mungkin berbeda dari hasil matematika yang diharapkan. Contoh berikut menunjukkan beberapa kasus seperti itu:

Console.WriteLine(.41f % .2f); // output: 0.00999999

double a = 0.1;
double b = 3 * a;
Console.WriteLine(b == 0.3);   // output: False
Console.WriteLine(b - 0.3);    // output: 5.55111512312578E-17

decimal c = 1 / 3.0m;
decimal d = 3 * c;
Console.WriteLine(d == 1.0m);  // output: False
Console.WriteLine(d);          // output: 0.9999999999999999999999999999

Untuk informasi selengkapnya, lihat keterangan di halaman referensi System.Double, System.Single, atau System.Decimal.

Kelebihan beban operator

Jenis yang ditentukan pengguna dapat membebani operator aritmetika tunggal (++, --, +, dan -) dan biner (*, /, %, +, dan -). JIka operator biner kelebihan beban, operator penetapan campuran yang sesuai juga secara implisit kelebihan beban. Jenis yang ditentukan pengguna tidak dapat secara eksplisit membebani operator penetapan majemuk.

Operator yang diperiksa yang ditentukan pengguna

Dimulai dengan C# 11, ketika Anda kelebihan beban operator aritmatika, Anda dapat menggunakan checked kata kunci untuk menentukan versi operator yang dicentang . Contoh berikut ini menunjukkan cara melakukannya:

public record struct Point(int X, int Y)
{
    public static Point operator checked +(Point left, Point right)
    {
        checked
        {
            return new Point(left.X + right.X, left.Y + right.Y);
        }
    }
    
    public static Point operator +(Point left, Point right)
    {
        return new Point(left.X + right.X, left.Y + right.Y);
    }
}

Saat menentukan operator yang dicentang, Anda juga harus menentukan operator yang sesuai tanpa pengubah checked . Operator yang diperiksa dipanggil dalam konteks yang dicentang; operator tanpa checked pengubah dipanggil dalam konteks yang tidak dicentang. Jika Anda hanya menyediakan operator tanpa pengubah checked , operator akan dipanggil dalam checked konteks dan unchecked .

Saat Anda menentukan kedua versi operator, diharapkan perilakunya hanya berbeda ketika hasil operasi terlalu besar untuk diwakili dalam jenis hasil sebagai berikut:

Operator yang diperiksa melempar OverflowException.
Operator tanpa pengubah checked mengembalikan instans yang mewakili hasil terpotong.

Untuk informasi tentang perbedaan perilaku operator aritmatika bawaan, lihat bagian Luapan aritmatika dan pembagian berdasarkan nol .

Anda dapat menggunakan pengubah checked hanya ketika Anda membebani salah satu operator berikut:

Operator unary ++, --, dan -
Operator biner *, /, +, dan -
Operator konversi eksplisit

Catatan

Konteks pemeriksaan luapan dalam isi operator yang diperiksa tidak terpengaruh oleh keberadaan pengubah checked . Konteks default ditentukan oleh nilai opsi pengkompilasi CheckForOverflowUnderflow. checked Gunakan pernyataan dan unchecked untuk secara eksplisit menentukan konteks pemeriksaan luapan, seperti contoh di awal bagian ini yang ditunjukkan.

Spesifikasi bahasa C#

Untuk informasi selengkapnya, lihat bagian berikut dari spesifikasi bahasa C#:

Bagikan melalui

Operator aritmetika (referensi C#)

Operator kenaikan ++

Operator kenaikan postfiks

Operator kenaikan prefiks

Operator pengurangan --

Operator penurunan postfiks

Operator penurunan prefiks

Operator plus dan minus tunggal

operasi perkalian *

operator pembagian /

Pembagian bilangan bulat

Pembagian titik mengambang

Operator sisa %

Sisa bilangan bulat

Sisa titik mengambang

operator tambahan +

operasi pengurangan -

Penetapan campuran

Asosiasivitas dan prioritas operator

Luapan aritmetika dan pembagian dengan nol

Luapan aritmetika bilangan bulat

Aritmetika Titik Mengambang

Kesalahan round-off

Kelebihan beban operator

Operator yang diperiksa yang ditentukan pengguna

Spesifikasi bahasa C#

Lihat juga

Saran dan Komentar

Sumber Daya Tambahan: