Akademi C# · Pelajaran

Amalan Terbaik Lebihan Muatan Operator

Pastikan operator lebihan muatan mudah difahami.

Pelajaran 4 daripada 413 langkah

Amalan Terbaik Lebihan Muatan Operator ialah pelajaran Akademi C# percuma di CoddyKit. Ini ialah pelajaran 4 daripada 4. Anda boleh membaca keseluruhan pelajaran di bawah secara percuma — kemudian berlatih secara praktikal dalam pelayar menggunakan penyunting kod terbina dalam dan tutor kecerdasan buatan 24/7. Pelajaran ini merupakan sebahagian daripada laluan pembelajaran Akademi C#, dan kemajuan anda disegerakkan merentas web serta aplikasi CoddyKit. Kursus Akademi C# merangkumi sejumlah 4 pelajaran.

Amalan Terbaik untuk Lebihan Beban Operator

Lebihan beban operator ialah alat yang berkuasa. Jika digunakan dengan baik, ia menjadikan jenis nilai intuitif; jika digunakan dengan buruk, ia menjadikan kod sukar difahami. Pelajaran ini merangkumi prinsip yang memastikan operator lebihan beban kekal boleh dijangka.

Lebihkan Beban Hanya Apabila Maknanya Jelas

Lebihkan beban operator hanya apabila maknanya tidak boleh disalah tafsir untuk jenis anda. + pada vektor jelas bermaksud penambahan mengikut komponen; + pada Order hanya akan mengelirukan pembaca.

using System;

public struct Vector2
{
    public int X, Y;
    public Vector2(int x, int y) { X = x; Y = y; }
    // + means adding components: obvious and expected
    public static Vector2 operator +(Vector2 a, Vector2 b)
        => new Vector2(a.X + b.X, a.Y + b.Y);
    public override string ToString() => "(" + X + ", " + Y + ")";
}

public class Program
{
    public static void Main()
    {
        Console.WriteLine(new Vector2(1, 2) + new Vector2(3, 4));
    }
}

Kekalkan Jangkaan Matematik

Pastikan operator selaras dengan intuisi: a + b harus sama dengan b + a apabila matematiknya komutatif, dan + tidak sepatutnya secara tersembunyi melakukan penolakan. Kejutan di sini menyebabkan pepijat halus.

using System;

public struct Money
{
    public decimal Amount;
    public Money(decimal a) { Amount = a; }
    public static Money operator +(Money a, Money b) => new Money(a.Amount + b.Amount);
    public override string ToString() => "$" + Amount;
}

public class Program
{
    public static void Main()
    {
        var x = new Money(3);
        var y = new Money(5);
        Console.WriteLine((x + y).Amount == (y + x).Amount); // commutative
    }
}

Kekalkan Simetri dan Pasangan

Bahasa memadankan operator tertentu, tetapi anda juga hendaklah mengekalkan simetri logik: jika anda menambah +, pertimbangkan -; jika anda menambah <, sediakan juga > dan varian yang melibatkan kesamaan. Set operator yang tidak lengkap mengecewakan pengguna.

using System;

public struct Length
{
    public int Mm;
    public Length(int mm) { Mm = mm; }
    public static Length operator +(Length a, Length b) => new Length(a.Mm + b.Mm);
    public static Length operator -(Length a, Length b) => new Length(a.Mm - b.Mm);
    public override string ToString() => Mm + "mm";
}

public class Program
{
    public static void Main()
    {
        Console.WriteLine(new Length(50) + new Length(20));
        Console.WriteLine(new Length(50) - new Length(20));
    }
}

Jangan Ubah Operan

Operator hendaklah tulen: kira dan pulangkan nilai baharu tanpa menyentuh operan. Mengubah operan dalam + mematahkan setiap jangkaan pembaca.

using System;

public struct Vector2
{
    public int X, Y;
    public Vector2(int x, int y) { X = x; Y = y; }
    public static Vector2 operator +(Vector2 a, Vector2 b)
        => new Vector2(a.X + b.X, a.Y + b.Y); // returns new, mutates nothing
    public override string ToString() => "(" + X + ", " + Y + ")";
}

public class Program
{
    public static void Main()
    {
        var a = new Vector2(1, 1);
        var unused = a + new Vector2(9, 9);
        Console.WriteLine("a is still " + a);
    }
}

Pastikan == Konsisten dengan Equals

Amalan terbaik yang sering diabaikan: setiap kali anda lebihkan beban ==, override Equals dan GetHashCode supaya semua laluan kesamaan sependapat. Ketidakselarasan di sini ialah salah satu pepijat operator yang paling lazim.

using System;

public struct Point
{
    public int X, Y;
    public Point(int x, int y) { X = x; Y = y; }
    public override bool Equals(object obj) => obj is Point p && p.X == X && p.Y == Y;
    public override int GetHashCode() => HashCode.Combine(X, Y);
    public static bool operator ==(Point a, Point b) => a.Equals(b);
    public static bool operator !=(Point a, Point b) => !a.Equals(b);
}

public class Program
{
    public static void Main()
    {
        Console.WriteLine(new Point(1, 1) == new Point(1, 1));
    }
}

Sediakan Alternatif Bernama

Sesetengah bahasa dan alat analisis tidak boleh menggunakan operator. Menawarkan kaedah bernama seperti Add bersama-sama + meningkatkan kesalingoperasian dan kebolehtemuan.

using System;

public struct Vector2
{
    public int X, Y;
    public Vector2(int x, int y) { X = x; Y = y; }
    public Vector2 Add(Vector2 other) => new Vector2(X + other.X, Y + other.Y);
    public static Vector2 operator +(Vector2 a, Vector2 b) => a.Add(b);
    public override string ToString() => "(" + X + ", " + Y + ")";
}

public class Program
{
    public static void Main()
    {
        var v = new Vector2(1, 2);
        Console.WriteLine(v.Add(new Vector2(3, 4)));
        Console.WriteLine(v + new Vector2(3, 4));
    }
}

Utamakan Operator pada Jenis Seperti Nilai

Operator terasa semula jadi pada jenis tidak berubah seperti nilai (struktur atau kelas seakan rekod). Bagi jenis yang boleh berubah dan sangat bergantung pada identiti, kaedah bernama biasanya menyampaikan niat dengan lebih baik.

using System;

public readonly struct Rational
{
    public readonly int Num, Den;
    public Rational(int n, int d) { Num = n; Den = d; }
    public static Rational operator *(Rational a, Rational b)
        => new Rational(a.Num * b.Num, a.Den * b.Den);
    public override string ToString() => Num + "/" + Den;
}

public class Program
{
    public static void Main()
    {
        Console.WriteLine(new Rational(1, 2) * new Rational(2, 3));
    }
}

Dokumentasikan Kes Pinggir

Nyatakan dengan jelas cara operator mengendalikan nilai khas: pembahagian dengan sifar, operan null untuk kelas atau limpahan. Pengendalian yang boleh dijangka mengelakkan pemanggil daripada terkejut.

using System;

public struct SafeDiv
{
    public int Value;
    public SafeDiv(int v) { Value = v; }
    // Documented behavior: dividing by zero yields zero
    public static SafeDiv operator /(SafeDiv a, SafeDiv b)
        => new SafeDiv(b.Value == 0 ? 0 : a.Value / b.Value);
    public override string ToString() => Value.ToString();
}

public class Program
{
    public static void Main()
    {
        Console.WriteLine(new SafeDiv(10) / new SafeDiv(0));
        Console.WriteLine(new SafeDiv(10) / new SafeDiv(2));
    }
}

Set Operator yang Berdisiplin

Jenis angka yang mantap menggabungkan beberapa operator intuitif, kesamaan yang konsisten dan ketidakbolehubahan. Hasilnya berkelakuan seperti nombor terbina dalam dan menyenangkan untuk digunakan.

using System;

public readonly struct Vec
{
    public readonly double X, Y;
    public Vec(double x, double y) { X = x; Y = y; }
    public static Vec operator +(Vec a, Vec b) => new Vec(a.X + b.X, a.Y + b.Y);
    public static Vec operator -(Vec a, Vec b) => new Vec(a.X - b.X, a.Y - b.Y);
    public static Vec operator *(Vec a, double k) => new Vec(a.X * k, a.Y * k);
    public override string ToString() => "(" + X + ", " + Y + ")";
}

public class Program
{
    public static void Main()
    {
        Console.WriteLine((new Vec(1, 2) + new Vec(3, 4)) * 2);
    }
}

Cuba Sendiri

Satukan amalan ini: jenis nilai tidak berubah, operator intuitif, alternatif bernama dan kesamaan yang konsisten.

using System;

public readonly struct Meters : IEquatable<Meters>
{
    public readonly double Value;
    public Meters(double v) { Value = v; }
    public Meters Add(Meters other) => new Meters(Value + other.Value);
    public static Meters operator +(Meters a, Meters b) => a.Add(b);
    public bool Equals(Meters other) => Value == other.Value;
    public override bool Equals(object obj) => obj is Meters m && Equals(m);
    public override int GetHashCode() => Value.GetHashCode();
    public static bool operator ==(Meters a, Meters b) => a.Equals(b);
    public static bool operator !=(Meters a, Meters b) => !a.Equals(b);
    public override string ToString() => Value + "m";
}

public class Program
{
    public static void Main()
    {
        Console.WriteLine(new Meters(3) + new Meters(4));
        Console.WriteLine(new Meters(7) == new Meters(7));
    }
}

Semakan Pantas

Gunakan amalan terbaik operator.

Jawab dalam pelajaran interaktif

Ringkasan

Lebihan beban operator yang baik adalah berdisiplin dan boleh dijangka.

Lebihkan beban hanya apabila maknanya jelas.
Kekalkan jangkaan matematik dan simetri.
Kekalkan ketulenan: pulangkan nilai baharu dan jangan ubah operan.
Pastikan == konsisten dengan Equals/GetHashCode.
Tawarkan alternatif bernama dan utamakan jenis seperti nilai.

Percuma untuk bermula

Pelajari C# dengan tutor kecerdasan buatan — percuma

Tulis dan jalankan kod sebenar dalam pelayar anda, dapatkan bantuan segera daripada tutor kecerdasan buatan yang tersedia 24/7, dan sambung semula dari tempat anda berhenti di web atau dalam aplikasi.

Kursus: 93
Pelajaran: 346

Mula belajar secara percuma Lihat kursus penuh

Soalan Lazim

Adakah pelajaran “Amalan Terbaik Lebihan Muatan Operator” percuma?

Ya — teks penuh “Amalan Terbaik Lebihan Muatan Operator” boleh dibaca secara percuma di web ini. Untuk berlatih secara interaktif menggunakan penyunting kod terbina dalam dan tutor kecerdasan buatan 24/7, serta membuka kunci baki kursus Akademi C#, tingkat taraf kepada CoddyKit PRO. Kursus Akademi C# merangkumi sejumlah 4 pelajaran.

Apakah yang akan saya pelajari dalam “Amalan Terbaik Lebihan Muatan Operator”?

Pastikan operator lebihan muatan mudah difahami. Anda berlatih Akademi C# menggunakan kod praktikal yang dijalankan terus dalam pelayar, manakala tutor kecerdasan buatan 24/7 menjawab soalan anda semasa anda mengikuti pelajaran.

Adakah saya memerlukan pengalaman untuk memulakan Akademi C#?

Tiada pengalaman terdahulu diperlukan. Pembelajaran Akademi C# di CoddyKit disusun untuk pelajar daripada peringkat pemula hingga lanjutan, jadi anda boleh bermula di sini atau dari awal dan belajar mengikut kadar anda sendiri. Ini ialah pelajaran 4 daripada 4.

Berapa lamakah pelajaran “Amalan Terbaik Lebihan Muatan Operator” diambil?

Kebanyakan pelajaran CoddyKit mengambil masa kira-kira 5–10 minit. Setiap pelajaran ringkas dan interaktif, jadi anda boleh membuat kemajuan secara berterusan dan menyambung tepat dari tempat anda berhenti di web atau aplikasi.

Bolehkah saya menulis dan menjalankan kod dalam pelajaran Akademi C# ini?

Ya. Setiap pelajaran Akademi C# menyertakan penyunting kod terbina dalam, jadi anda boleh menulis dan menjalankan kod sebenar terus dalam pelayar serta menerima maklum balas kecerdasan buatan serta-merta — tanpa memerlukan persediaan setempat.

Semua pelajaran dalam kursus ini

← Kembali ke Akademi C#