Surcharge de l'opérateur C # pour `+ =`?

J'essaie de faire des surcharges d'opérateurs pour +=, mais je ne peux pas. Je ne peux faire une surcharge d'opérateur que pour +.

Comment venir?

Éditer

La raison pour laquelle cela ne fonctionne pas est que j'ai une classe Vector (avec un champ X et Y). Prenons l'exemple suivant.

vector1 += vector2;

Si ma surcharge d'opérateur est définie sur:

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

Ensuite, le résultat ne sera pas ajouté à vector1, mais à la place, vector1 deviendra également un tout nouveau vecteur par référence.

Opérateurs surchargeables , de MSDN:

Les opérateurs d'affectation ne peuvent pas être surchargés, mais +=, par exemple, sont évalués à l'aide de +, qui peut être surchargé.

De plus, aucun opérateur d'affectation ne peut être surchargé. Je pense que c'est parce qu'il y aura un effet pour le ramassage des ordures et la gestion de la mémoire, qui est une faille de sécurité potentielle dans le monde à fort typage CLR.

Néanmoins, voyons ce qu'est exactement un opérateur. Selon le célèbre livre de Jeffrey Richter , chaque langage de programmation a sa propre liste d'opérateurs, qui sont compilées dans un appel de méthode spécial, et CLR lui-même ne sait rien des opérateurs. Voyons donc ce qui reste exactement derrière les opérateurs +et +=.

Voir ce code simple:

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

Voyons le code IL pour ces instructions:

  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

Voyons maintenant ce code:

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

Et le code IL pour cela:

  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

Ils sont égaux! Ainsi, l' +=opérateur n'est que du sucre syntaxique pour votre programme en C # , et vous pouvez simplement surcharger l' +opérateur.

Par exemple:

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

Ce code sera compilé et exécuté avec succès en tant que:

  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

Mettre à jour:

Selon votre mise à jour - comme le dit @EricLippert, vous devriez vraiment avoir les vecteurs comme un objet immuable. Le résultat de l'ajout des deux vecteurs est un nouveau vecteur, pas le premier avec des tailles différentes.

Si, pour une raison quelconque, vous devez changer le premier vecteur, vous pouvez utiliser cette surcharge (mais comme pour moi, c'est un comportement très étrange):

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

Je pense que vous trouverez ce lien informatif: les opérateurs surchargeables

Les opérateurs d'affectation ne peuvent pas être surchargés, mais + =, par exemple, est évalué à l'aide de +, qui peut être surchargé.

C'est pour la même raison que l'opérateur d'affectation ne peut pas être surchargé. Vous ne pouvez pas écrire de code qui effectuerait correctement l'affectation.

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

Les opérateurs d'affectation ne peuvent pas être surchargés, mais + =, par exemple, est évalué à l'aide de +, qui peut être surchargé.

De MSDN .

Vous ne pouvez pas surcharger +=car ce n'est pas vraiment un opérateur unique, c'est juste du sucre syntaxique . x += yest juste une manière abrégée d'écrire x = x + y. Comme il +=est défini en termes d' opérateurs +et =, vous permettre de le remplacer séparément pourrait créer des problèmes, dans les cas où x += yet x = x + yne se comporterait pas exactement de la même manière.

À un niveau inférieur, il est très probable que le compilateur C # compile les deux expressions dans le même bytecode, ce qui signifie qu'il est très probable que le runtime ne puisse pas les traiter différemment pendant l'exécution du programme.

Je peux comprendre que vous souhaitiez peut-être le traiter comme une opération séparée: dans une instruction comme x += 10vous savez que vous pouvez muter l' xobjet sur place et peut-être économiser du temps / de la mémoire, plutôt que de créer un nouvel objet x + 10avant de l'assigner sur l'ancienne référence .

Mais considérez ce code:

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

Devrait a == bà la fin? Pour la plupart des types, non, ac'est 10 de plus que b. Mais si vous pouviez surcharger l' +=opérateur pour qu'il mute sur place, alors oui. Maintenant, considérez cela aet bpourrait être transmis à des parties éloignées du programme. Votre éventuelle optimisation pourrait créer des bogues déroutants si votre objet commence à changer là où le code ne l'attend pas.

En d'autres termes, si les performances sont si importantes, ce n'est pas trop difficile à remplacer x += 10par un appel de méthode comme x.increaseBy(10), et c'est beaucoup plus clair pour toutes les personnes impliquées.

C'est parce que cet opérateur ne peut pas être surchargé:

Les opérateurs d'affectation ne peuvent pas être surchargés, mais + =, par exemple, est évalué à l'aide de +, qui peut être surchargé.

MSDN

Surcharger simplement l' +opérateur, à cause de

x += y égal à x = x + y

La surcharge de l'opérateur pour +est utilisée dans l' +=opérateur, A += Bégale à A = operator+(A, B).

Si vous surchargez l' +opérateur comme ceci:

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

tu peux faire

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

ou

 foo = foo + 10;

Cela compilera et fonctionnera de la même manière.

Il y a toujours la même réponse à ce problème: pourquoi avez-vous besoin du +=, si vous l'obtenez gratuitement si vous surchargez le fichier +. Mais que se passe-t-il si j'ai une classe comme celle-ci.

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

Dites-vous toujours qu'il est bon que le +=soit "implémenté automatiquement". Si vous essayez de faire du calcul haute performance en C #, vous devez avoir de telles fonctionnalités pour réduire le temps de traitement et la consommation de mémoire, si quelqu'un a une bonne solution, c'est très apprécié, mais ne me dites pas que je dois le faire avec des méthodes statiques , ce n'est qu'une solution de contournement et je ne vois aucune raison pour laquelle C # fait l' +=implémentation s'il n'est pas défini, et s'il est défini, il sera utilisé. Certaines personnes disent que ne pas avoir de différence entre +et +=empêche les erreurs, mais n'est-ce pas mon propre problème?

J'ai eu exactement la même question et je ne peux pas y répondre mieux que cette personne a

Une meilleure méthode de conception est le casting explicite. Vous pouvez certainement surcharger Casting.