Question

如何让它发挥作用？

使用int的{{1}}是否会导致float被隐式提升为int（或float）？

double

public static float [ ] operator / ( float [ ] a , int b ) { float [ ] c = new float [ a . Count ( ) ]; for ( int i = 0 ; i < a . Count ( ) ; i++ ) { c[i] += a [ i ] / b; } return c; }

编译器正在操作运算符声明（/），而不是正文。

Answer 1

必须在相关类中声明操作符＆＃39;身体。这意味着您的重载运算符必须包含新类型的类型＆＃34; /＆＃34;功能在于。

但是，阵列实现没有代码空间（内部化）。因此，与C ++不同，在不修改类型的情况下实现目标是不可能。

以下是几种可行的方法：

包装一个实现浮动数组（或列表）的全新类，在新类中定义运算符。
编写一个单独的函数而不是运算符。
最好的方法，创建一个更高级的包装器类 - 请参阅Jordao在here中的答案，您只需要修改数组的声明方式。

Answer 2

你可以选择这样的东西

class FloatArray
{
    float[] arr;
    public FloatArray(float[] arr)
    {
        this.arr = arr;
    }
    public static float[] operator /(FloatArray a, int[] b)
    {
        var res = new float[a.arr.Length];
        for (int i = 0; i < a.arr.Length; i++)
        {
            res[i] = a.arr[i] / b[i];
        }
        return res;
    }
    public static implicit operator FloatArray(float[] arr)
    {
        return new FloatArray(arr);
    }
}

用法：

        var floats = new float[] { 20f, 30f };
        var ints = new int[] { 10, 6 };
        var result = (FloatArray)floats / ints;

Answer 3

如果我错了，请纠正我。我认为实施是错误的。数学声明中的构建差距很小，特别是隐含的浮标升级促销。

如果公众是危险的，请考虑在课堂上私下。

我接近这些。注释的代码块未编译但它应该。

       public static Vertex operator / ( Vertex a , Vertex b )
            {
            Vertex c = new Vertex ( );
            c . x = a . x / b . x;
            c . y = a . y / b . y;
            c . z = a . z / b . z;
            return c;
            }
        public static Vertex operator / ( Vertex a , float b )
            {
            Vertex c = new Vertex ( );
            c . x = a . x / b;
            c . y = a . y / b;
            c . z = a . z / b;
            return c;
            }
        public static Vertex operator / ( Vertex a , int b )
            {
            Vertex c = new Vertex ( );
            c . x = a . x / b;
            c . y = a . y / b;
            c . z = a . z / b;
            return c;
            }
        public static Vertex operator + ( Vertex a , Vertex b )
            {
            Vertex c = new Vertex ( );
            c . x = a . x + b . x;
            c . y = a . y + b . y;
            c . z = a . z + b . z;
            return c;
            }
        public static implicit operator float[] ( Vertex a )
            {
            float [ ] f = new float [ 3 ];
            f [ 0 ] = a . x;
            f [ 1 ] = a . y;
            f [ 3 ] = a . z;
            return f;
            }


    //public dynamic float [ ] operator / ( float[] a, int b )
    //    {
    //    float [ ] c = new float [ a . Count ( ) ];
    //    for ( int i = 0 ; i < a . Count ( ) ; i++ )
    //        {
    //        c[i] += a [ i ] / b;
    //        }
    //    return c;
    //    }
    float [ ] NewCentroidf3 ( Vertex v0 , Vertex v1 )
        {
        float[] C = new float[3];

        C = v0 + v1;
        //C /= 2.0f;
        //C = C / 2; // would work if above worked.

        C [ 0 ] /= 2.0f;
        C [ 1 ] /= 2.0f;
        C [ 2 ] /= 2.0f;
        return C;
        }

我们正在考虑将“扩展运算符”添加到C＃的假设未来版本中，这将解决您的问题。稻草民意调查：你们有没有这个功能的真棒场景？我们可以获得的真实场景越多，某天功能实施的可能性就越大。以我的方式发送他们;您可以使用我博客上的电子邮件链接。 - Eric Lippert 09年11月6日15:15

public static float [] operator /（float [] a，int b）将无法编译

3 个答案: