Quá tải toán tử C # cho `+ =`?

Tôi đang cố gắng thực hiện quá tải toán tử cho +=, nhưng tôi không thể. Tôi chỉ có thể làm cho một toán tử quá tải cho +.

Làm thế nào mà?

Biên tập

Lý do điều này không hoạt động là tôi có một lớp Vector (với một trường X và Y). Hãy xem xét ví dụ sau.

vector1 += vector2;

Nếu quá tải toán tử của tôi được đặt thành:

public static Vector operator +(Vector left, Vector right)
{
    return new Vector(right.x + left.x, right.y + left.y);
}

Sau đó, kết quả sẽ không được thêm vào vector1, mà thay vào đó, vector1 cũng sẽ trở thành một Vector hoàn toàn mới theo tham chiếu.

Các nhà khai thác quá tải , từ MSDN:

Các toán tử gán không thể được nạp chồng, nhưng +=ví dụ, được đánh giá bằng cách sử dụng +, có thể được nạp chồng.

Thậm chí, không có toán tử gán nào có thể bị quá tải. Tôi nghĩ điều này là do sẽ có ảnh hưởng đến việc thu thập Rác và quản lý bộ nhớ, đây là một lỗ hổng bảo mật tiềm ẩn trong thế giới được đánh máy mạnh mẽ của CLR.

Tuy nhiên, hãy xem toán tử chính xác là gì. Theo cuốn sách nổi tiếng của Jeffrey Richter , mỗi ngôn ngữ lập trình đều có danh sách toán tử riêng, được biên dịch theo các lệnh gọi phương thức đặc biệt, và bản thân CLR không biết gì về toán tử. Vì vậy, chúng ta hãy xem những gì chính xác nằm sau toán tử +và +=.

Xem mã đơn giản này:

Decimal d = 10M;
d = d + 10M;
Console.WriteLine(d);

Hãy xem mã IL để biết hướng dẫn này:

  IL_0000:  nop
  IL_0001:  ldc.i4.s   10
  IL_0003:  newobj     instance void [mscorlib]System.Decimal::.ctor(int32)
  IL_0008:  stloc.0
  IL_0009:  ldloc.0
  IL_000a:  ldc.i4.s   10
  IL_000c:  newobj     instance void [mscorlib]System.Decimal::.ctor(int32)
  IL_0011:  call       valuetype [mscorlib]System.Decimal [mscorlib]System.Decimal::op_Addition(valuetype [mscorlib]System.Decimal,
                                                                                                valuetype [mscorlib]System.Decimal)
  IL_0016:  stloc.0

Bây giờ chúng ta hãy xem mã này:

Decimal d1 = 10M;
d1 += 10M;
Console.WriteLine(d1);

Và mã IL cho điều này:

  IL_0000:  nop
  IL_0001:  ldc.i4.s   10
  IL_0003:  newobj     instance void [mscorlib]System.Decimal::.ctor(int32)
  IL_0008:  stloc.0
  IL_0009:  ldloc.0
  IL_000a:  ldc.i4.s   10
  IL_000c:  newobj     instance void [mscorlib]System.Decimal::.ctor(int32)
  IL_0011:  call       valuetype [mscorlib]System.Decimal [mscorlib]System.Decimal::op_Addition(valuetype [mscorlib]System.Decimal,
                                                                                                valuetype [mscorlib]System.Decimal)
  IL_0016:  stloc.0

Họ đều bình đẳng! Vì vậy, +=toán tử chỉ là đường cú pháp cho chương trình của bạn trong C # , và bạn có thể nạp chồng +toán tử một cách đơn giản .

Ví dụ:

class Foo
{
    private int c1;

    public Foo(int c11)
    {
        c1 = c11;
    }

    public static Foo operator +(Foo c1, Foo x)
    {
        return new Foo(c1.c1 + x.c1);
    }
}

static void Main(string[] args)
{
    Foo d1 =  new Foo (10);
    Foo d2 = new Foo(11);
    d2 += d1;
}

Mã này sẽ được biên dịch và chạy thành công dưới dạng:

  IL_0000:  nop
  IL_0001:  ldc.i4.s   10
  IL_0003:  newobj     instance void ConsoleApplication2.Program/Foo::.ctor(int32)
  IL_0008:  stloc.0
  IL_0009:  ldc.i4.s   11
  IL_000b:  newobj     instance void ConsoleApplication2.Program/Foo::.ctor(int32)
  IL_0010:  stloc.1
  IL_0011:  ldloc.1
  IL_0012:  ldloc.0
  IL_0013:  call       class ConsoleApplication2.Program/Foo ConsoleApplication2.Program/Foo::op_Addition(class ConsoleApplication2.Program/Foo,
                                                                                                          class ConsoleApplication2.Program/Foo)
  IL_0018:  stloc.1

Cập nhật:

Theo Bản cập nhật của bạn - như @EricLippert nói, bạn thực sự nên có các vectơ như một đối tượng bất biến. Kết quả của việc thêm hai vectơ là một vectơ mới , không phải là vectơ đầu tiên có kích thước khác nhau.

Nếu vì lý do nào đó mà bạn cần thay đổi vectơ đầu tiên, bạn có thể sử dụng quá tải này (nhưng đối với tôi, đây là hành vi rất lạ):

public static Vector operator +(Vector left, Vector right)
{
    left.x += right.x;
    left.y += right.y;
    return left;
}

Tôi nghĩ bạn sẽ thấy liên kết này có nhiều thông tin: Các nhà khai thác quá tải

Các toán tử gán không thể được nạp chồng, nhưng + =, ví dụ, được đánh giá bằng cách sử dụng +, có thể được nạp chồng.

Điều này là do cùng một lý do mà toán tử gán không thể được nạp chồng. Bạn không thể viết mã thực hiện nhiệm vụ một cách chính xác.

class Foo
{
   // Won't compile.
   public static Foo operator= (Foo c1, int x)
   {
       // duh... what do I do here?  I can't change the reference of c1.
   }
}

Các toán tử gán không thể được nạp chồng, nhưng + =, ví dụ, được đánh giá bằng cách sử dụng +, có thể được nạp chồng.

Từ MSDN .

Bạn không thể quá tải +=vì nó không thực sự là một toán tử duy nhất, nó chỉ là một đường cú pháp . x += ychỉ là một cách viết tắt x = x + y. Bởi vì +=được định nghĩa theo thuật ngữ +và =toán tử, việc cho phép bạn ghi đè nó một cách riêng biệt có thể tạo ra các vấn đề, trong những trường hợp xảy ra x += yvà x = x + ykhông hoạt động theo cùng một cách.

Ở cấp độ thấp hơn, rất có thể trình biên dịch C # biên dịch cả hai biểu thức xuống cùng một mã byte, có nghĩa là rất có thể thời gian chạy không thể xử lý chúng khác nhau trong quá trình thực thi chương trình.

Tôi có thể hiểu rằng bạn có thể muốn coi nó như một thao tác riêng biệt: trong một câu lệnh như x += 10bạn biết rằng bạn có thể thay đổi xđối tượng tại chỗ và có thể tiết kiệm một chút thời gian / bộ nhớ, thay vì tạo một đối tượng mới x + 10trước khi gán nó trên tham chiếu cũ .

Nhưng hãy xem xét mã này:

a = ...
b = a;
a += 10;

a == bCuối cùng có nên không? Đối với hầu hết các loại, không, anhiều hơn 10 b. Nhưng nếu bạn có thể quá tải +=toán tử để thay đổi tại chỗ, thì có. Bây giờ hãy xem xét điều đó avà bcó thể được chuyển đến các phần xa của chương trình. Việc tối ưu hóa khả thi của bạn có thể tạo ra các lỗi khó hiểu nếu đối tượng của bạn bắt đầu thay đổi ở nơi mã không mong đợi.

Nói cách khác, nếu hiệu suất là quan trọng, không quá khó để thay thế x += 10bằng một cuộc gọi phương thức như thế nào x.increaseBy(10)và nó rõ ràng hơn rất nhiều cho tất cả mọi người tham gia.

Điều này là do toán tử này không thể bị quá tải:

Các toán tử gán không thể được nạp chồng, nhưng + =, ví dụ, được đánh giá bằng cách sử dụng +, có thể được nạp chồng.

MSDN

Chỉ cần quá tải +toán tử, vì

x += y tương đương với x = x + y

Quá tải toán tử for +được sử dụng trong +=toán tử, A += Bbằng với A = operator+(A, B).

Nếu bạn quá tải +toán tử như thế này:

class Foo
{
    public static Foo operator + (Foo c1, int x)
    {
        // implementation
    }
}

bạn có thể làm

 Foo foo = new Foo();
 foo += 10;

hoặc là

 foo = foo + 10;

Điều này sẽ biên dịch và chạy như nhau.

Luôn có cùng một câu trả lời cho vấn đề này: Tại sao bạn cần +=, nếu bạn nhận được miễn phí nếu bạn quá tải +. Nhưng điều gì sẽ xảy ra nếu tôi có một lớp học như thế này.

using System;
using System.IO;

public class Class1
{
    public class MappableObject
    {
        FileStream stream;

        public  int Blocks;
        public int BlockSize;

        public MappableObject(string FileName, int Blocks_in, int BlockSize_in)
        {
            Blocks = Blocks_in;
            BlockSize = BlockSize_in;

            // Just create the file here and set the size
            stream = new FileStream(FileName); // Here we need more params of course to create a file.
            stream.SetLength(sizeof(float) * Blocks * BlockSize);
        }

        public float[] GetBlock(int BlockNo)
        {
            long BlockPos = BlockNo * BlockSize;

            stream.Position = BlockPos;

            using (BinaryReader reader = new BinaryReader(stream))
            {
                float[] resData = new float[BlockSize];
                for (int i = 0; i < BlockSize; i++)
                {
                    // This line is stupid enough for accessing files a lot and the data is large
                    // Maybe someone has an idea to make this faster? I tried a lot and this is the simplest solution
                    // for illustration.
                    resData[i] = reader.ReadSingle();
                }
            }

            retuen resData;
        }

        public void SetBlock(int BlockNo, float[] data)
        {
            long BlockPos = BlockNo * BlockSize;

            stream.Position = BlockPos;

            using (BinaryWriter reader = new BinaryWriter(stream))
            {
                for (int i = 0; i < BlockSize; i++)
                {
                    // Also this line is stupid enough for accessing files a lot and the data is large
                    reader.Write(data[i];
                }
            }

            retuen resData;
        }

        // For adding two MappableObjects
        public static MappableObject operator +(MappableObject A, Mappableobject B)
        {
            // Of course we have to make sure that all dimensions are correct.

            MappableObject result = new MappableObject(Path.GetTempFileName(), A.Blocks, A.BlockSize);

            for (int i = 0; i < Blocks; i++)
            {
                float[] dataA = A.GetBlock(i);
                float[] dataB = B.GetBlock(i);

                float[] C = new float[dataA.Length];

                for (int j = 0; j < BlockSize; j++)
                {
                    C[j] = A[j] + B[j];
                }

                result.SetBlock(i, C);
            }
        }

        // For adding a single float to the whole data.
        public static MappableObject operator +(MappableObject A, float B)
        {
            // Of course we have to make sure that all dimensions are correct.

            MappableObject result = new MappableObject(Path.GetTempFileName(), A.Blocks, A.BlockSize);

            for (int i = 0; i < Blocks; i++)
            {
                float[] dataA = A.GetBlock(i);

                float[] C = new float[dataA.Length];

                for (int j = 0; j < BlockSize; j++)
                {
                    C[j] = A[j] + B;
                }

                result.SetBlock(i, C);
            }
        }

        // Of course this doesn't work, but maybe you can see the effect here.
        // when the += is automimplemented from the definition above I have to create another large
        // object which causes a loss of memory and also takes more time because of the operation -> altgough its
        // simple in the example, but in reality it's much more complex.
        public static MappableObject operator +=(MappableObject A, float B)
        {
            // Of course we have to make sure that all dimensions are correct.

            MappableObject result = new MappableObject(Path.GetTempFileName(), A.Blocks, A.BlockSize);

            for (int i = 0; i < Blocks; i++)
            {
                float[] dataA = A.GetBlock(i);

                for (int j = 0; j < BlockSize; j++)
                {
                    A[j]+= + B;
                }

                result.SetBlock(i, A);
            }
        }
    }
}

Bạn vẫn nói rằng điều tốt +=là "tự động thực hiện". Nếu bạn cố gắng thực hiện tính toán hiệu suất cao trong C #, bạn cần phải có các tính năng như vậy để giảm thời gian xử lý và tiêu thụ bộ nhớ, nếu ai đó có giải pháp tốt sẽ được đánh giá cao, nhưng đừng nói với tôi rằng tôi phải làm điều này với phương pháp tĩnh , đây chỉ là một giải pháp thay thế và tôi không thấy lý do gì tại sao C # +=thực hiện triển khai nếu nó không được xác định và nếu nó được định nghĩa thì nó sẽ được sử dụng. Một số người nói rằng không có sự khác biệt giữa +và +=ngăn ngừa lỗi, nhưng đây không phải là vấn đề của riêng tôi?

Tôi đã có cùng một câu hỏi và tôi không thể trả lời nó tốt hơn khi người này có

Một phương pháp thiết kế tốt hơn là Truyền rõ ràng. Bạn chắc chắn có thể truyền quá tải.