`+ =`에 대한 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이 참조에 의해 완전히 새로운 Vector가됩니다.

MSDN의 Overloadable Operators :

할당 연산자는 오버로드 할 수 없지만 +=예를 들어는 +오버로드 될 수있는를 사용하여 평가됩니다 .

더욱이 할당 연산자는 오버로드 될 수 없습니다. 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가 말했듯이 실제로 벡터는 불변 객체로 있어야합니다. 두 벡터를 더한 결과는 크기가 다른 첫 번째 벡터가 아니라 새 벡터입니다.

어떤 이유로 첫 번째 벡터를 변경해야하는 경우이 오버로드를 사용할 수 있습니다 (하지만 저에게는 매우 이상한 동작입니다).

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

이 링크가 유익하다고 생각합니다. Overloadable Operators

할당 연산자는 오버로드 할 수 없지만, 예를 들어 + =는 오버로드 될 수있는 +를 사용하여 평가됩니다.

이는 할당 연산자를 오버로드 할 수없는 것과 같은 이유 때문입니다. 할당을 올바르게 수행하는 코드를 작성할 수 없습니다.

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. 때문에 +=의 관점에서 정의 +하고 =당신이 경우에 문제를 만들 수 별도로 오버라이드 (override) 할 수 있도록 사업자 x += y와 x = x + y동일한 방식으로 행동하지 않았다.

낮은 수준에서는 C # 컴파일러가 두 식을 동일한 바이트 코드로 컴파일 할 가능성이 매우 높습니다. 즉, 프로그램 실행 중에 런타임에서 이러한 식을 다르게 처리 할 수 없을 가능성이 매우 높습니다 .

나는 당신이 그것을 별도의 작업처럼 취급하고 싶을 수도 있다는 것을 이해할 수 있습니다 : x += 10당신이 알고있는 것과 같은 문장에서, 당신 이 이전 참조 위에 그것을 할당하기 전에 x새로운 객체 x + 10를 생성하는 것보다 제자리 에서 객체를 변형 하고 아마도 약간의 시간 / 메모리를 절약 할 수 있다는 것을 알 수 있습니다. .

그러나 다음 코드를 고려하십시오.

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

해야 a == b끝에? 대부분의 유형에서 아니오 a는 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 #이 구현을 수행하고 정의 된 경우 사용되는 이유가 없습니다. 어떤 사람들은 차이 가지고 있지 말 +과 +=방지 오류를, 그러나 이것은 내 자신의 문제가 아니다?

나는 똑같은 질문을 가지고 있었고 나는 이 사람이 가지고있는 것보다 더 잘 대답 할 수 없습니다.

더 나은 설계 방법은 Explicit Casting입니다. 확실히 캐스팅에 과부하가 걸릴 수 있습니다.