Bagikan melalui

Operator aritmetika (referensi C#)

Operator berikut melakukan operasi aritmetika dengan operand jenis numerik:

Semua jenis numerik integral dan floating-point mendukung operator ini.

Jenis int, , uintlong, dan ulong menentukan semua operator ini. Jenis integral lainnya (sbyte, byte, short, ushort, dan char) hanya menentukan operator ++ dan --. Untuk operator lain, jika Anda menggunakan jenis sbyteintegral , , byte, ushortshort, atau char sebagai operand, nilai dikonversi ke int jenis dan jenis hasilnya adalah int. Jika operand adalah jenis integral atau floating-point yang berbeda, nilainya dikonversi ke jenis yang paling berisi, 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.

Referensi bahasa C# mendokumentasikan versi bahasa C# yang paling baru dirilis. Ini juga berisi dokumentasi awal untuk fitur dalam pratinjau publik untuk rilis bahasa yang akan datang.

Dokumentasi mengidentifikasi fitur apa pun yang pertama kali diperkenalkan dalam tiga versi terakhir bahasa atau dalam pratinjau publik saat ini.

Petunjuk / Saran

Untuk menemukan kapan fitur pertama kali diperkenalkan di C#, lihat artikel tentang riwayat versi bahasa C#.

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

Hasilnya 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

Hasilnya ++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 penurunan tersedia dalam dua bentuk: operator penurunan pascafiks, x--, dan operator penurunan awalan, --x.

Operator penurunan postfiks

Hasilnya 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

Hasilnya --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 operan jenis bilangan bulat, hasil / operator adalah jenis bilangan bulat dan sama dengan kuota dua operand yang dibulatkan ke arah 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 kuota dari dua operan sebagai angka floating-point, gunakan float, , doubleatau decimal ketik:

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

floatUntuk jenis , double, dan decimal , / operator mengembalikan kuota 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 satu operand adalah decimal, operand lainnya tidak dapat atau floatdouble, karena tidak float juga double memiliki konversi implisit ke 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 operan tipe bilangan bulat, hasilnya a % b adalah nilai yang dihasilkan oleh $a - \frac{a}{b} \times b$. Tanda sisa bukan nol cocok dengan tanda 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, cocok dengan tanda x.
  • Nilai absolut berasal dari perhitungan $|x| - n \kali |y|$, dengan n bilangan z bulat terbesar kurang dari atau sama dengan $\frac{|x|}{|y|}$. Di sini, $|x|$ dan $|y|$ mewakili nilai x absolut dan y, masing-masing.

Catatan

Metode komputasi sisanya ini mirip dengan metode yang digunakan untuk operan 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 decimal operand, operator % yang tersisa berfungsi sama dengan operator sisa jenis System.Decimal .

Contoh berikut menunjukkan bagaimana operator sisa berperilaku dengan operand floating-point:

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 tangan kanan dari operand sebelah kiri:

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 menghapus delegasi. Untuk informasi selengkapnya, lihat - operator dan -=.

Penetapan campuran

Untuk op operator biner, ekspresi penetapan campuran dari formulir

x op= y

Setara dengan

x = x op y

Kecuali bahwa 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 dapat dikonversi secara implisit ke jenis Tx. 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 aritmatika dari prioritas tertinggi hingga prioritas terendah:

  • Operator kenaikan x++ dan penurunan postfiks x--
  • Prefiks kenaikan ++x dan pengurangan --x operator, dan operator unary + dan -
  • Operator multiplikatif *, /, dan %
  • Operator tambahan + dan -

Operator aritmetika biner bersifat asosiatif kiri. Artinya, pengkompilasi mengevaluasi operator dengan tingkat prioritas yang sama 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.

Catatan

Pembagian bilangan bulat memiliki kasus khusus di mana dapat ArithmeticException dilemparkan bahkan dalam konteks yang tidak dicentang. Ketika operand kiri adalah nilai minimum dari jenis bilangan bulat yang ditandatangani (int.MinValue atau long.MinValue) dan operand kanan adalah -1, hasilnya tidak dapat diwakili dalam jenis tujuan. Runtime .NET melemparkan ArithmeticException dalam hal ini, seperti yang ditunjukkan dalam contoh berikut:

int a = int.MinValue;
int b = -1;
try
{
    int c = unchecked(a / b);
}
catch (ArithmeticException)
{
    Console.WriteLine($"Overflow occurred when dividing {a} by {b}.");
}

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 aritmatika dengan menggunakan float jenis dan double tidak pernah melemparkan pengecualian. Hasil operasi aritmatika menggunakan 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 dalam representasi floating-point dari bilangan riil dan aritmatika floating-point, kesalahan round-off dapat terjadi dalam perhitungan yang menggunakan jenis floating-point. Hasil ekspresi 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

Anda dapat membebani operator aritmetika unary (++, --, +, dan -) dan biner (*, /, %, +, dan -) untuk jenis yang ditentukan pengguna. Ketika Anda membebani operator biner secara implisit, Anda juga secara implisit membebani operator penetapan majemuk yang sesuai. Dimulai dengan C# 14, jenis yang ditentukan pengguna dapat secara eksplisit membebani operator penetapan majemuk (op=) untuk memberikan implementasi yang lebih efisien. Biasanya, tipe meng-overload operator ini karena nilainya bisa diperbarui di tempat, daripada mengalokasikan instans baru untuk menyimpan hasil operasi. Jika jenis tidak memberikan kelebihan beban eksplisit, pengkompilasi menghasilkan kelebihan beban implisit.

Operator yang diperiksa yang ditentukan pengguna

Saat Anda membebani operator aritmatika secara berlebih, 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 . Konteks yang dicentang memanggil operator yang dicentang, dan konteks yang tidak dicentang memanggil operator tanpa checked pengubah.

Saat Anda menentukan kedua versi operator, 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 -
  • Penugasan gabungan *=, /=, +=, dan -= operator (C# 14 dan yang lebih baru)
  • Operator konversi eksplisit

Catatan

Pengubah checked tidak memengaruhi konteks pemeriksaan luapan dalam isinya. Konteks default ditentukan oleh nilai opsi pengkompilasi CheckForOverflowUnderflow. checked 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#:

Lihat juga

  • Last updated on