`+ =`のC＃演算子のオーバーロード？

の演算子のオーバーロードを実行しようとしていますが、実行+=できません。の演算子をオーバーロードにすることしかできません+。

どうして？

編集する

これが機能しない理由は、Vectorクラス（XおよびYフィールド付き）があるためです。次の例を考えてみましょう。

vector1 += vector2;

オペレーターのオーバーロードが次のように設定されている場合：

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

その後、結果はvector1に追加されませんが、代わりにvector1も参照によりまったく新しいベクターになります。

オーバーロード可能な演算子、MSDNから：

代入演算子はオーバーロードできませんが+=、たとえば、は+オーバーロードできるを使用して評価されます。

さらに、どの代入演算子もオーバーロードできません。これは、ガベージコレクションとメモリ管理に影響が出るためだと思います。これは、CLRの強い型指定の世界で潜在的なセキュリティホールになります。

それでも、演算子とは何かを見てみましょう。有名なJeffrey Richterの本によると、各プログラミング言語には独自の演算子リストがあり、特別なメソッド呼び出しでコンパイルされており、CLR自体は演算子について何も知りません。では+、+=演算子と演算子の後ろに何が残っているかを見てみましょう。

次の簡単なコードをご覧ください。

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

この手順のILコードを見てみましょう。

  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

このコードを見てみましょう：

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

そしてこれのためのILコード：

  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

彼らは等しいです！したがって、+=演算子はC＃でのプログラムの単なる構文上の砂糖であり、+演算子を単純にオーバーロードできます。

例えば：

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

このコードはコンパイルされ、次のように正常に実行されます。

  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

更新：

あなたのアップデートによると-@EricLippertが言うように、あなたは本当に不変のオブジェクトとしてベクトルを持つべきです。2つのベクトルを追加した結果は、サイズの異なる最初のベクトルではなく、新しいベクトルです。

何らかの理由で最初のベクトルを変更する必要がある場合は、このオーバーロードを使用できます（ただし、私にとっては、これは非常に奇妙な動作です）。

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

このリンクは参考になると思います：オーバーロード可能な演算子

代入演算子はオーバーロードできませんが、たとえば+ =は、オーバーロード可能な+を使用して評価されます。

これは、代入演算子をオーバーロードできないのと同じ理由によるものです。割り当てを正しく実行するコードは記述できません。

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

代入演算子はオーバーロードできませんが、たとえば+ =は、オーバーロード可能な+を使用して評価されます。

MSDNから。

+=これは実際には一意の演算子ではないため、オーバーロードすることはできません。単なる構文上の糖です。x += yはの速記x = x + yです。そのため+=の用語で定義されている+と、=あなたはケースで、問題を作成することができ、別途、それを上書きすることができ、事業者x += yとx = x + yまったく同じように動作しませんでした。

下位レベルでは、C＃コンパイラーが両方の式を同じバイトコードにコンパイルする可能性が非常に高いため、プログラムの実行中にランタイムがそれらを異なる方法で処理できない可能性が高くなります。

私はあなたがそれを別の操作のように扱いたいかもしれないことを理解できます：古い参照に割り当てる前に新しいオブジェクトを作成するのではなくx += 10、xオブジェクトを所定の位置に変更して時間とメモリを節約できることを知っているようなステートメントでx + 10。

しかし、このコードを考えてみましょう：

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

a == b最後にすべきですか？ほとんどのタイプでは、いいえ、a10以上ですb。しかし、+=演算子をオーバーロードして所定の場所で変異させることができれば、そうです。それaを考えてみてください。そうbすれば、プログラムの遠い部分に回ることができます。コードが予期しない場所でオブジェクトが変化し始めると、可能な最適化によって混乱するバグが発生する可能性があります。

つまり、パフォーマンスがそれほど重要である場合、のx += 10ようなメソッド呼び出しに置き換えるのはそれほど難しくなくx.increaseBy(10)、関係者全員にとって非常に明確です。

これは、この演算子をオーバーロードできないためです。

代入演算子はオーバーロードできませんが、たとえば+ =は、オーバーロード可能な+を使用して評価されます。

MSDN

+演算子をオーバーロードするだけです。

x += y に等しい x = x + y

演算子のオーバーロード+が+=演算子で使用され、A += Bと等しいA = operator+(A, B)。

+このように演算子をオーバーロードすると：

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

できるよ

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

または

 foo = foo + 10;

これにより、コンパイルと実行が同じになります。

この問題には常に同じ答えがあり+=ます+。をオーバーロードした場合に無料で入手できるのに、なぜが必要なのですか。しかし、このようなクラスがあるとどうなりますか。

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

それでも+=「自動実装」するのが良いと言いますか？C＃でハイパフォーマンスコンピューティングを行おうとする場合、処理時間とメモリ消費を削減するための機能が必要です。良い解決策があれば高く評価されますが、静的メソッドでこれを行う必要があると言わないでください。 、これは回避策にすぎず、 C＃が+=定義されていない場合に実装が行われる理由はわかりません。定義されている場合は、使用されます。一部の人々は違いがないとエラー+を+=防ぐと言いますが、これは私自身の問題ではありませんか？

私はまったく同じ質問をしました、そして私はおそらくこの人が持っているより良い答えはできません

より良い設計方法は、明示的キャストです。あなたは間違いなくキャスティングをオーバーロードすることができます。