C# 重载+；运算符添加两个数组

这个C代码怎么了？我试图重载+运算符以添加两个数组，但收到如下错误消息：

二进制运算符的参数之一必须是包含类型

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

类程序
{
公共静态void Main（字符串[]args）
{
常数int n=5；
int[]a=新的int[n]{1,2,3,4,5}；
int[]b=新的int[n]{5,4,3,2,1}；
int[]c=新的int[n]；
//c=添加（a，b）；
c=a+b；
对于（int i=0；i

当您想在AA和BB类型之间重载le+运算符时，必须在AA或BB类中执行，而不是在名为Program的类中执行（就像您所做的那样）

不幸的是，无法在数组类中编写代码

你能做的就是

• 创建自己的实现IList的类
• 并在该类上使用+运算符

---

如果您需要更详细的实现，请询问我。

它声明操作符的一个参数需要与操作符函数的成员具有相同的类型。因此，如果运算符函数是MyClass的成员，则其中一个参数的类型必须为MyClass

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

class-MyClass
{
...
公共静态int[]运算符+（MyClass x，int[]y）
//公共静态int[]Add（int[]x，int[]y）
{
int[]z=新的int[x.Length]；
对于（int i=0；i

运算符必须在“相关”类的主体中声明。例如：

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

由于您没有访问阵列实现的权限，因此最好将阵列包装到您自己的实现中，以便提供其他操作（这是使operator+工作的唯一方法）

另一方面，您可以定义如下扩展方法：

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

---

仍然会导致自然调用（

x.Add（y）

），同时避免在自己的类中包装数组。

只能向自己创建的类型添加运算符。

int[]

是一种内置类型，不能向其添加运算符

---

您可以创建自己的类来封装数组，并向其中添加运算符。

您可以使用以下方法：

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

类程序{
静态void Main（字符串[]参数）{
常数int n=5；
var a=newint[n]{1,2,3,4,5}.WithOperators（）；
VarB=新整数[n]{5,4,3,2,1}；
int[]c=a+b；
对于（int i=0；ia+b.ToArray（）；
}
}

---

基于我写的一篇相关文章。

MSDN过载教程页面有更多信息-这可能是您的答案：我们正在考虑添加“扩展运算符”假设未来版本的C#，这将解决你的问题。斯特劳民意测验：你们中有人对此功能有很棒的场景吗？我们能得到的场景越逼真，某一天实现该功能的可能性就越大。按我的方式发送；你可以使用我博客上的电子邮件链接。谢谢Eric。这是否意味着我们也会得到它“Extension Everything”：）我们如何做到这一点，或者在我成为多神教之前我应该放弃多态性？很遗憾，类无法实现

this[int]

，以匹配数组订阅的行为（返回

byref

而不是值）。我最初对此进行了升级，因为我的第一次阅读是这样的，它可以让编译器认为您在数组上定义了方法。但是，经过反思，我发现它只允许您隐藏这样一个事实，即您所做的是用一层间接寻址来包装数组。包装数组是获得+运算符的简单而明显的解决方案，但是它引入了我不想要的其他开销。是的，包装数组是获得所需内容的简单方法，但这并不是全部内容。隐式转换运算符使您可以更轻松地从包装器移动到数组，反之亦然。最后，这只是一个如何伪造扩展运算符的想法，但绝对不是完美的。