Überladen des Operators + zum Hinzufügen von zwei Arrays

Question

Was ist falsch an diesem C# -Code? Ich habe versucht, den Operator + zu überladen, um zwei Arrays hinzuzufügen, aber eine Fehlermeldung wie folgt erhalten:

Einer der Parameter eines binären Operators muss der Typ enthalten sein.

class Program 
{ 
    public static void Main(string[] args) 
    { 
     const int n = 5; 

     int[] a = new int[n] { 1, 2, 3, 4, 5 }; 
     int[] b = new int[n] { 5, 4, 3, 2, 1 }; 
     int[] c = new int[n]; 

     // c = Add(a, b); 
     c = a + b; 

     for (int i = 0; i < c.Length; i++) 
     { 
     Console.Write("{0} ", c[i]); 
     } 

     Console.WriteLine(); 
    } 

    public static int[] operator+(int[] x, int[] y) 
    // public static int[] Add(int[] x, int[] y) 
    { 
     int[] z = new int[x.Length]; 

     for (int i = 0; i < x.Length; i++) 
     { 
     z[i] = x[i] + y[i]; 
     } 

     return (z); 
    } 
} 

Answer 1

Bediener müssen in einem "verwandten" Klassenkörper deklariert werden. Zum Beispiel:

public class Foo 
{ 
    int X; 

    // Legal 
    public static int operator+(int x, Foo y); 

    // This is not 
    public static int operator+(int x, int y); 
} 

Da Sie keinen Zugriff auf die Implementierung von Arrays haben, Ihre beste Wette würde entweder wickeln Sie Ihre Arrays in Ihrer eigenen Implementierung, so dass Sie zusätzliche Operationen zur Verfügung stellen können (und dies ist der einzige Weg, .

public static class ArrayHelper 
{ 
    public static int[] Add(this int[] x, int[] y) { ... } 
} 

die natürlichen Gespräche (x.Add(y)) unter Vermeidung von noch wickeln Arrays in Ihrer eigenen Klasse führen: den Operator + Arbeit

auf der anderen Seite zu machen, könnten Sie eine Erweiterungsmethode wie definieren.

Answer 2

Wenn Sie le + Operator zwischen Typ AA und BB zu überlasten wollen, müssen Sie es in der Klasse AA oder BB tun und nicht in einer Klasse mit dem Namen Programm (wie Sie haben).

Leider können Sie Code in der Array Klasse nicht schreiben.

Was Sie tun können, ist zu

• Ihre eigene Klasse erstellen, die IList
• und setzen Sie den Operator + auf dieser Klasse implementiert.

Wenn Sie detailliertere Implementierung benötigen, fragen Sie mich einfach.

Answer 3

Es besagt, dass einer der Parameter für den Operator vom gleichen Typ sein muss wie die Operatorfunktion. Wenn die Operatorfunktion ein Mitglied von MyClass ist, muss einer der Parameter vom Typ MyClass sein.

class MyClass 
{ 
... 

public static int[] operator+(MyClass x, int[] y) 
    // public static int[] Add(int[] x, int[] y) 
    { 
     int[] z = new int[x.Length]; 

     for (int i = 0; i < x.Length; i++) 
     { 
     z[i] = x[i] + y[i]; 
     } 

     return (z); 
    } 
} 

Answer 4

Sie können einem Typ, den Sie selbst erstellen, nur Operatoren hinzufügen. A int[] ist ein eingebauter Typ, dem Sie keine Operatoren hinzufügen können.

Sie könnten Ihre eigene Klasse erstellen, die ein Array einkapselt, und den Operator hinzufügen.

Answer 5

Sie können so etwas wie folgt verwenden:

class Program { 
    static void Main(string[] args) { 
    const int n = 5; 

    var a = new int[n] { 1, 2, 3, 4, 5 }.WithOperators(); 
    var b = new int[n] { 5, 4, 3, 2, 1 }; 

    int[] c = a + b; 

    for (int i = 0; i < c.Length; i++) { 
     Console.Write("{0} ", c[i]); 
    } 

    Console.WriteLine(); 
    } 
} 

public static class Int32ArrayExtensions { 
    public static Int32ArrayWithOperators WithOperators(this int[] self) { 
    return self; 
    } 
} 

public class Int32ArrayWithOperators { 
    int[] _array; 

    public Int32ArrayWithOperators(int[] array) { 
    if (array == null) throw new ArgumentNullException("array"); 
    _array = array; 
    } 

    public static implicit operator Int32ArrayWithOperators(int[] array) { 
    return new Int32ArrayWithOperators(array); 
    } 
    public static implicit operator int[](Int32ArrayWithOperators wrapper) { 
    return wrapper._array; 
    } 

    public static Int32ArrayWithOperators operator +(Int32ArrayWithOperators left, Int32ArrayWithOperators right) { 
    var x = left._array; 
    var y = right._array; 
    return x.Zip(y, (a, b) => a + b).ToArray(); 
    } 
} 

Basierend auf einem verwandten post, die ich geschrieben habe.