Ví dụ về quá tải toán tử, có nghĩa là [đóng]

Trong khi tôi học C #, tôi thấy rằng, C # hỗ trợ quá tải toán tử. Tôi có vấn đề với ví dụ tốt đó:

1. Có ý nghĩa (ví dụ: thêm lớp có tên cừu và bò)
2. Không phải là một ví dụ về nối hai chuỗi

Ví dụ từ Thư viện lớp cơ sở được chào đón.

Các ví dụ rõ ràng về quá tải toán tử thích hợp là bất kỳ lớp nào hoạt động giống như cách các số hoạt động. Vì vậy, bigint lớp (như Jalayn gợi ý), số phức hoặc ma trận lớp (như Superbest gợi ý) tất cả đều có các hoạt động tương tự mà con số bình thường đã rất bản đồ thực sự tốt vào khai thác toán học, trong khi thời gian hoạt động (theo đề nghị của svick ) bản đồ độc đáo vào một tập hợp con của những hoạt động đó.

Tóm tắt hơn, các toán tử có thể được sử dụng khi thực hiện tập hợp như các phép toán, vì vậy operator+có thể là một phép hợp , operator-có thể là phần bù, v.v ... Điều này bắt đầu kéo dài mô hình, đặc biệt là nếu bạn sử dụng toán tử cộng hoặc nhân cho một thao tác không phải là ' t giao hoán , như bạn có thể mong đợi chúng được.

Bản thân C # có một ví dụ tuyệt vời về quá tải toán tử không số . Nó sử dụng +=và -=để cộng và trừ các đại biểu , tức là đăng ký và hủy đăng ký chúng. Điều này hoạt động tốt bởi vì +=và các -=toán tử hoạt động như bạn mong đợi, và điều này dẫn đến mã ngắn gọn hơn nhiều.

Đối với người theo chủ nghĩa thuần túy, một trong những vấn đề với +toán tử chuỗi là nó không giao hoán. "a"+"b"không giống như "b"+"a". Chúng tôi hiểu ngoại lệ này cho các chuỗi vì nó rất phổ biến, nhưng làm thế nào chúng ta có thể biết nếu sử dụng operator+trên các loại khác sẽ có giao hoán hay không? Hầu hết mọi người sẽ cho rằng nó là như vậy, trừ khi đối tượng giống như chuỗi , nhưng bạn không bao giờ thực sự biết mọi người sẽ giả định gì.

Cũng như các chuỗi, các phần tử của ma trận cũng khá nổi tiếng. Rõ ràng đó Matrix operator* (double, Matrix)là một phép nhân vô hướng, trong khi đó Matrix operator* (Matrix, Matrix)sẽ là một phép nhân ma trận (ví dụ như một ma trận của phép nhân sản phẩm chấm).

Tương tự như vậy, việc sử dụng các toán tử với các đại biểu rõ ràng đã bị loại bỏ khỏi toán học đến mức bạn khó có thể mắc phải những sai lầm đó.

Tình cờ, tại hội nghị ACCU 2011 , Roger Orr & Steve Love đã trình bày một phiên về Một số đối tượng bình đẳng hơn những đối tượng khác - một cái nhìn về nhiều ý nghĩa của sự bình đẳng, giá trị và bản sắc . Các slide của họ có thể tải xuống , như Phụ lục của Richard Harris về sự bình đẳng điểm nổi . Tóm tắt: Hãy thật cẩn thận với operator==, đây là những con rồng!

Quá tải toán tử là một kỹ thuật ngữ nghĩa rất mạnh, nhưng nó dễ sử dụng quá mức. Lý tưởng nhất là bạn chỉ nên sử dụng nó trong các tình huống khi nó rất rõ ràng từ ngữ cảnh tác động của một toán tử quá tải là gì. Trong nhiều cách a.union(b)rõ hơn a+b, và a*blà nhiều hơn che khuất hơn a.cartesianProduct(b), đặc biệt là kể từ khi kết quả của một sản phẩm Descartes sẽ là một SetLike<Tuple<T,T>>chứ không phải là một SetLike<T>.

Các vấn đề thực sự với quá tải toán tử xuất hiện khi một lập trình viên giả định một lớp sẽ hành xử theo một cách, nhưng nó thực sự hành xử theo cách khác. Loại xung đột ngữ nghĩa này là những gì tôi cho rằng điều quan trọng là phải cố gắng tránh.

Tôi ngạc nhiên không ai đề cập đến một trong những trường hợp thú vị hơn trong BCL: DateTimevà TimeSpan. Bạn có thể:

• cộng hoặc trừ hai TimeSpans để lấy số khácTimeSpan
• sử dụng trừ unary trên a TimeSpanđể có được phủ địnhTimeSpan
• trừ hai DateTimes để có được mộtTimeSpan
• cộng hoặc trừ TimeSpantừ a DateTimeđể lấy cái khácDateTime

Một tập hợp các toán mà có thể có ý nghĩa trên nhiều loại là <, >, <=, >=. Trong BCL, ví dụ Versionthực hiện chúng.

Ví dụ đầu tiên tôi nghĩ đến là việc triển khai BigInteger , cho phép bạn làm việc với các số nguyên có chữ ký lớn. Kiểm tra liên kết MSDN để xem có bao nhiêu toán tử đã bị quá tải (nghĩa là có một danh sách lớn và tôi không kiểm tra xem tất cả các toán tử đã bị quá tải hay chưa, nhưng chắc chắn là như vậy)

Ngoài ra, vì tôi cũng làm Java và Java không cho phép các toán tử quá tải, nên viết nó cực kỳ ngọt ngào

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

Hơn, trong Java:

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

Tôi rất vui vì tôi đã thấy điều này bởi vì tôi đã bị lừa với Irony và nó có một cách sử dụng quá tải toán tử TUYỆT VỜI. Đây là một mẫu của những gì nó có thể làm.

Vì vậy, Irony là một "Bộ thực thi ngôn ngữ .NET" và là trình tạo trình phân tích cú pháp (tạo trình phân tích cú pháp LALR). Thay vì phải học một cú pháp / ngôn ngữ mới như các trình tạo trình phân tích cú pháp như yacc / lex, bạn viết ngữ pháp bằng C # với sự quá tải của toán tử. Đây là một ngữ pháp BNF đơn giản

// 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

Vì vậy, đây là một ngữ pháp nhỏ đơn giản (xin vui lòng xin lỗi nếu có sự không nhất quán vì tôi chỉ học BNF và xây dựng ngữ pháp). Bây giờ hãy xem 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("+") | "-" | "*" | "/" | "**";

Như bạn có thể thấy, với toán tử quá tải, viết ngữ pháp bằng C # gần như viết chính xác ngữ pháp trong BNF. Đối với tôi, điều đó không chỉ có ý nghĩa mà còn là một công dụng tuyệt vời của quá tải toán tử.

Ví dụ chính là toán tử == / toán tử! =.

Nếu bạn muốn dễ dàng so sánh hai đối tượng với các giá trị dữ liệu thay vì tham chiếu, bạn sẽ muốn quá tải .Equals (and.GetHashCode!) Và có thể muốn thực hiện các toán tử! = Và == để thống nhất.

Tôi chưa bao giờ thấy bất kỳ sự quá tải hoang dã nào của các nhà khai thác khác trong C # (tôi tưởng tượng có những trường hợp cạnh có thể hữu ích mặc dù).

Ví dụ này từ MSDN cho thấy cách triển khai các số phức và cho chúng sử dụng toán tử + bình thường.

Một ví dụ khác cho thấy cách thực hiện để thêm ma trận và cũng giải thích cách không sử dụng nó để thêm xe vào gara (đọc liên kết).

Sử dụng tốt quá tải có thể là hiếm, nhưng nó xảy ra.

quá tải toán tử == và toán tử! = hiển thị hai trường phái suy nghĩ: những trường hợp nói điều đó làm cho mọi việc dễ dàng hơn và những người chống lại việc nói điều đó ngăn cản việc so sánh địa chỉ (ví dụ: tôi chỉ vào cùng một vị trí trong bộ nhớ, không chỉ là một bản sao của cùng một vật).

Tôi thấy quá tải toán tử diễn viên sẽ có ích trong các tình huống cụ thể. Ví dụ, tôi đã phải tuần tự hóa / giải tuần tự hóa trong XML một boolean được biểu diễn là 0 hoặc 1. Toán tử chuyển quyền (ẩn hoặc rõ ràng, tôi quên) từ boolean sang int và back đã thực hiện thủ thuật.

Chúng không thuộc danh mục những thứ mà mọi người thường nghĩ đến khi chúng quá tải toán tử, nhưng tôi nghĩ một trong những toán tử quan trọng nhất có thể quá tải là toán tử chuyển đổi .

Toán tử chuyển đổi đặc biệt hữu ích cho các loại giá trị có thể "khử đường" thành loại số hoặc có thể hoạt động như một loại số trong một số ngữ cảnh. Ví dụ: bạn có thể xác định một Idloại đặc biệt đại diện cho một mã định danh nhất định và bạn có thể cung cấp một chuyển đổi ngầm định để intbạn có thể chuyển Idmột phương thức có một int, nhưng một chuyển đổi bùng nổ từ đó intsang Idkhông ai có thể chuyển intvào phương pháp mà Idkhông cần đúc nó trước.

Như một ví dụ bên ngoài C #, ngôn ngữ Python bao gồm nhiều hành vi đặc biệt được triển khai dưới dạng toán tử quá tải. Chúng bao gồm intoán tử để kiểm tra thành viên, ()toán tử để gọi một đối tượng như thể đó là một hàm và lentoán tử để xác định chiều dài hoặc kích thước của một đối tượng.

Và sau đó, bạn có các ngôn ngữ như Haskell, Scala và nhiều ngôn ngữ chức năng khác, trong đó các tên như +chỉ là các hàm thông thường và không phải là toán tử nào cả (và có hỗ trợ ngôn ngữ để sử dụng các hàm ở vị trí trung gian).

Các điểm Struct trong System.Drawing namespace sử dụng được quá tải để so sánh hai địa điểm khác nhau sử dụng toán tử quá tải.

 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" );

Như bạn có thể thấy, việc so sánh tọa độ X và Y của hai vị trí sử dụng quá tải sẽ dễ dàng hơn nhiều.

Nếu bạn quen thuộc với vectơ toán học, bạn có thể thấy việc sử dụng quá tải +toán tử. Bạn có thể thêm một vectơ a=[1,3]với b=[2,-1]và nhận c=[3,2].

Quá tải các giá trị bằng (==) cũng có thể hữu ích (mặc dù có thể tốt hơn để thực hiện một equals()phương thức). Để tiếp tục các ví dụ vector:

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

Hãy tưởng tượng một đoạn mã để vẽ trên một biểu mẫu

{
  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.
  ..
}

Một ví dụ phổ biến khác là khi một cấu trúc được sử dụng để giữ thông tin vị trí dưới dạng một vectơ.

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 };
    }
}

chỉ được sử dụng sau này như

{
    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;
}