Contoh overloading operator, yang masuk akal [ditutup]

Sementara saya belajar C #, saya menemukan bahwa, C # mendukung overloading operator. Saya punya masalah dengan contoh bagus yang:

1. Masuk akal (mis. Menambahkan kelas bernama domba dan sapi)
2. Bukan contoh gabungan dari dua string

Contoh dari Perpustakaan Kelas Dasar dipersilakan.

Contoh nyata dari overloading operator yang tepat adalah setiap kelas yang berperilaku dengan cara yang sama seperti angka beroperasi. Jadi BigInt kelas (sebagai Jalayn menyarankan), bilangan kompleks atau matriks kelas (sebagai Superbest menyarankan) semua memiliki operasi yang sama yang nomor biasa telah begitu memetakan dengan sangat baik ke operator matematika, sementara waktu operasi (seperti yang disarankan oleh svick ) map baik ke subset dari operasi tersebut.

Sedikit lebih abstrak, operator dapat digunakan ketika melakukan operasi seperti set , sehingga operator+bisa menjadi gabungan , operator-bisa menjadi pelengkap, dll. Ini memang mulai memperluas paradigma, terutama jika Anda menggunakan operator penambahan atau gandakan untuk operasi yang tidak t komutatif , seperti yang Anda harapkan.

C # sendiri memiliki contoh kelebihan operator non-numerik . Ia menggunakan +=dan -=untuk menambah dan mengurangi delegasi , yaitu mendaftar dan tidak mendaftar. Ini bekerja dengan baik karena operator +=dan -=bekerja seperti yang Anda harapkan, dan ini menghasilkan kode yang lebih ringkas.

Untuk purist, salah satu masalah dengan +operator string adalah ia tidak komutatif. "a"+"b"tidak sama dengan "b"+"a". Kami memahami pengecualian untuk string ini karena itu sangat umum, tetapi bagaimana kami bisa tahu apakah menggunakan operator+pada tipe lain akan komutatif atau tidak? Kebanyakan orang akan berasumsi bahwa itu adalah, kecuali objeknya seperti string , tetapi Anda tidak pernah benar-benar tahu apa yang akan diasumsikan orang.

Seperti halnya string, kelemahan matriks juga cukup terkenal. Jelas bahwa itu Matrix operator* (double, Matrix)adalah perkalian skalar, sedangkan Matrix operator* (Matrix, Matrix)akan menjadi perkalian matriks (yaitu matriks perkalian titik-produk) misalnya.

Demikian pula penggunaan operator dengan delegasi jelas sekali jauh dari matematika sehingga Anda tidak mungkin membuat kesalahan itu.

Kebetulan, pada konferensi ACCU 2011 , Roger Orr & Steve Love mempresentasikan sesi tentang beberapa objek yang lebih setara daripada yang lain - lihat banyak makna persamaan, nilai, dan identitas . Slide-slide mereka dapat diunduh , seperti Lampiran Richard Harris tentang kesetaraan floating point . Ringkasan: Berhati-hatilah dengan operator==, ini naga!

Overloading operator adalah teknik semantik yang sangat kuat, tetapi mudah digunakan secara berlebihan. Idealnya Anda hanya boleh menggunakannya dalam situasi ketika sangat jelas dari konteks apa efek dari operator kelebihan beban. Dalam banyak hal a.union(b)lebih jelas daripada a+b, dan a*badalah jauh lebih jelas daripada a.cartesianProduct(b), terutama karena hasil produk Cartesian akan menjadi SetLike<Tuple<T,T>>daripada SetLike<T>.

Masalah sebenarnya dengan overloading operator datang ketika seorang programmer menganggap suatu kelas akan berperilaku dalam satu cara, tetapi sebenarnya berperilaku di lain. Bentrokan semantik semacam ini adalah apa yang saya sarankan penting untuk dihindari.

Saya terkejut tidak ada yang menyebutkan salah satu kasus yang lebih menarik di BCL: DateTimedan TimeSpan. Kamu bisa:

• tambah atau kurangi dua TimeSpans untuk mendapatkan yang lainTimeSpan
• gunakan minus unary pada TimeSpanuntuk mendapatkan negasiTimeSpan
• kurangi dua DateTimes untuk mendapatkanTimeSpan
• menambah atau mengurangi TimeSpandari DateTimeuntuk mendapatkan yang lainDateTime

Set operator yang bisa masuk akal pada banyak jenis yang <, >, <=, >=. Di BCL, misalnya Versionmengimplementasikannya.

Contoh pertama yang muncul di benak saya adalah implementasi BigInteger , yang memungkinkan Anda untuk bekerja dengan bilangan bulat bertanda besar. Lihat tautan MSDN untuk melihat berapa banyak operator yang kelebihan beban (yaitu, ada daftar besar, dan saya tidak memeriksa apakah semua operator kelebihan beban, tapi sepertinya begitu)

Juga, karena saya juga melakukan Java dan Java tidak memungkinkan operator overload, itu sangat manis untuk menulis

BigInteger bi = new BigInteger(0);
bi += 10;

Daripada di Jawa:

BigDecimal bd = new BigDecimal(0);
bd = bd.add(new BigDecimal(10));

Saya senang melihat ini karena saya telah bermain-main dengan Irony dan memiliki penggunaan operator yang berlebihan. Berikut adalah contoh apa yang dapat dilakukannya.

Jadi Irony adalah ".NET Language Implementation Kit" dan merupakan parser generator (menghasilkan parser LALR). Alih-alih harus mempelajari sintaks / bahasa baru seperti generator parser seperti yacc / lex Anda menulis tata bahasa di C # dengan operator kelebihan. Berikut ini adalah tata bahasa BNF sederhana

// BNF 
Expr := Term | BinExpr
Term := number | ParExpr
ParExpr := "(" + Expr + ")"
BinExpr := number + BinOp + number
BinOp := "+" | "-" | "*" | "/"
number := 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9

Jadi ini adalah tata bahasa kecil yang sederhana (permisi jika ada ketidakkonsistenan karena saya baru belajar BNF dan membuat tata bahasa). Sekarang mari kita lihat C #:

  var Expr = new NonTerminal("Expr");
  var Term = new NonTerminal("Term");
  var BinExpr = new NonTerminal("BinExpr");
  var ParExpr = new NonTerminal("ParExpr");
  var BinOp = new NonTerminal("BinOp");
  var Statement = new NonTerminal("Statement");
  var ProgramLine = new NonTerminal("ProgramLine");
  var Program = new NonTerminal("Program", typeof(StatementListNode));
  // BNF Rules - Overloading
  Expr.Rule = Term | BinExpr;
  Term.Rule = number | ParExpr;
  ParExpr.Rule = "(" + Expr + ")";
  BinExpr.Rule = Expr + BinOp + Expr;
  BinOp.Rule = ToTerm("+") | "-" | "*" | "/" | "**";

Seperti yang Anda lihat, dengan operator kelebihan, menulis tata bahasa di C # hampir persis menulis tata bahasa di BNF. Bagi saya, itu tidak hanya masuk akal tetapi juga penggunaan berlebihan operator.

Contoh kuncinya adalah operator == / operator! =.

Jika Anda ingin dengan mudah membandingkan dua objek dengan nilai data alih-alih dengan referensi, Anda akan ingin membebani .Equals (and.GetHashCode!), Dan mungkin ingin melakukan operator! = Dan == juga untuk konsistensi.

Saya belum pernah melihat kelebihan liar dari operator lain di C # (saya membayangkan ada kasus tepi di mana mungkin berguna).

Contoh dari MSDN ini menunjukkan bagaimana menerapkan bilangan kompleks dan meminta mereka menggunakan operator + normal.

Contoh lain menunjukkan bagaimana melakukannya untuk penambahan matriks, dan juga menjelaskan bagaimana tidak menggunakannya untuk menambahkan mobil ke garasi (baca tautannya).

Penggunaan kelebihan muatan yang baik bisa jarang terjadi, tetapi itu memang terjadi.

operator overloading == dan operator! = menunjukkan dua aliran pemikiran: yang untuk mengatakan hal itu membuat segalanya lebih mudah, dan mereka yang menolak mengatakan hal itu mencegah membandingkan alamat (yaitu saya menunjuk ke tempat yang persis sama dalam memori, bukan hanya salinan yang sama obyek).

Saya merasa operator overload berguna dalam situasi tertentu. Sebagai contoh, saya harus membuat serial / deserialize dalam XML boolean direpresentasikan sebagai 0 atau 1. Hak (implisit atau eksplisit, saya lupa) melemparkan operator dari boolean ke int dan kembali melakukan trik.

Mereka tidak termasuk dalam kategori hal-hal yang biasanya dipikirkan orang ketika mereka melakukan overloading pada operator, tapi saya pikir salah satu operator yang paling penting untuk dapat overload adalah operator konversi .

Operator konversi sangat berguna untuk tipe nilai yang dapat "mengurangi gula" menjadi tipe numerik, atau dapat bertindak seperti tipe numerik dalam beberapa konteks. Sebagai contoh, Anda mungkin mendefinisikan khusus Idjenis yang mewakili pengenal tertentu, dan Anda bisa memberikan implisit konversi ke intsehingga Anda dapat melewati Idke metode yang mengambil sebuah int, tapi explict konversi dari intke Idsehingga tidak ada yang bisa lulus intmenjadi metode yang membutuhkan Idtanpa casting terlebih dahulu.

Sebagai contoh di luar C #, bahasa Python mencakup banyak perilaku khusus yang diterapkan sebagai operator yang kelebihan beban. Ini termasuk inoperator untuk pengujian keanggotaan, ()operator untuk memanggil objek seolah-olah itu fungsi, dan lenoperator untuk menentukan panjang atau ukuran suatu objek.

Dan kemudian Anda memiliki bahasa seperti Haskell, Scala, dan banyak bahasa fungsional lainnya, di mana nama seperti +hanya fungsi biasa, dan bukan operator sama sekali (dan ada dukungan bahasa untuk menggunakan fungsi dalam posisi infix).

The Titik Struct di System.Drawing namespace menggunakan overloading untuk membandingkan dua lokasi yang berbeda menggunakan operator overloading.

 Point locationA = new Point( 50, 50 );
 Point locationB = new Point( 50, 50 );

 if ( locationA == locationB )
    Console.WriteLine( "Their locations are the same" );
 else
    Console.WriteLine( "Their locations  are different" );

Seperti yang Anda lihat, jauh lebih mudah untuk membandingkan koordinat X dan Y dari dua lokasi menggunakan kelebihan beban.

Jika Anda terbiasa dengan vektor matematika Anda mungkin melihat kegunaan dalam membebani +operator. Anda dapat menambahkan vektor a=[1,3]dengan b=[2,-1]dan dapatkan c=[3,2].

Kelebihan yang sama dengan (==) juga bisa menjadi berguna (meskipun mungkin lebih baik untuk menerapkan equals()metode). Untuk melanjutkan contoh-contoh vektor:

v1=[1,3]
v2=[1,3]
v1==v2 // True

Bayangkan sepotong kode untuk menggambar pada formulir

{
  Point p = textBox1.Location;
  Size dp = textBox1.Size;

  // Here the + operator has been overloaded by the CLR
  p += dp;  // Now p points to the lower right corner of the textbox.
  ..
}

Contoh umum lainnya adalah ketika struktur digunakan untuk menyimpan informasi posisi dalam bentuk vektor.

public struct Pos
{
    public double x, y, z;
    public double Distance { get { return Math.Sqrt(x * x + y * y + z * z); } }
    public static Pos operator +(Pos A, Pos B)
    {
        return new Pos() { x = A.x + B.x, y = A.y + B.y, z = A.z + B.z };
    }
    public static Pos operator -(Pos A, Pos B)
    {
        return new Pos() { x = A.x - B.x, y = A.y - B.y, z = A.z - B.z };
    }
}

hanya untuk digunakan nanti sebagai

{
    Pos A = new Pos() { x = 4, y = -1, z = 0.5 };
    Pos B = new Pos() { x = 8, y = 2, z = 1.5 };

    double x = (B - A).Distance;
}