Question

我正在尝试制作代表四维矢量的结构。

我做了这样的事情：

struct Vector4D<T> 
{
    public T v1;
    public T v2;
    public T v3;
    public T v4;

    //...

    public static Vector4D<T> operator *(Vector4D<T> a, T b)
    {
        a.v1 *= b;
        a.v2 *= b;
        a.v3 *= b;
        a.v4 *= b;
        return a;
    }
}

好吧，如果T不是任何数字类型，如Int32，Int64，Double，Single，Decimal等，这个结构都没有意义......

所以，我的问题是如何将T限制为以下类型之一：Int16，Int32，Int64，UInt16，UInt32，UInt64，Byte，SByte，Single，Double，Decimal？

我正在尝试做这样的事情

struct Vector4D<T> where T : Int16, Int32, Int64 // and so go on
{
    //....
}

但它没有用。

Answer 1

您必须为每种类型显式写一个乘法方法。

但是，您可以稍微简化一下，因为这个可编译的代码示例显示：

using System;

namespace Demo
{
    internal class Program
    {
        static void Main()
        {
            var d = new Vector4D<double>{v1=1, v2=2, v3=3, v4=4};
            Console.WriteLine(d*2); // Prints 2, 4, 6, 8

            var i = new Vector4D<int>{v1=1, v2=2, v3=3, v4=4};
            Console.WriteLine(i*2); // Prints 2, 4, 6, 8

            // This will throw a "NotSupported" exception:
            var s = new Vector4D<string>{v1="1", v2="2", v3="3", v4="4"};
            Console.WriteLine(s*"");
        }
    }

    partial struct Vector4D<T>
    {
        public T v1;
        public T v2;
        public T v3;
        public T v4;

        public static Vector4D<T> operator *(Vector4D<T> a, T b)
        {
            a.v1 = multiply(a.v1, b);
            a.v2 = multiply(a.v2, b);
            a.v3 = multiply(a.v3, b);
            a.v4 = multiply(a.v4, b);
            return a;
        }

        public override string ToString()
        {
            return string.Format("v1: {0}, v2: {1}, v3: {2}, v4: {3}", v1, v2, v3, v4);
        }

        private static Func<T, T, T> multiply;
    }

    // Partial just to keep this logic separate.

    partial struct Vector4D<T>
    {
        static Vector4D() // Called only once for each T.
        {
            if (typeof(T) == typeof(int))
                Vector4D<int>.multiply = (a, b) => a*b;
            else if (typeof(T) == typeof(double))
                Vector4D<double>.multiply = (a, b) => a*b;
            else if (typeof(T) == typeof(float))
                Vector4D<float>.multiply = (a, b) => a*b;
            else
                multiply = (a, b) =>
                {
                    string message = string.Format("Vector4D<{0}> not supported.", typeof(T));
                    throw new NotSupportedException(message);
                };
        }
    }
}

这样，您可以将所有乘法（并且可能是除法，加法和减法）逻辑放入第二个部分结构中，并将它们与主逻辑分开。

第二个部分结构只包含一个静态类型构造函数，对于每个用于创建结构的类型T，它只会被调用一次（每个程序集域）。

你确实有查询类型的开销，但每次运行程序只有一次，我猜测开销会很低。

此外，你根本没有使用部分结构 - 你可以将静态类型构造函数与结构实现的其余部分放在一起。我只将它作为一个例子分开，因为它是纯粹的初始化逻辑，你可以将它与结构逻辑的其余部分分开考虑。

重要请注意，如果您使用的Vector4D类型尚未定义乘法运算，则会在NotSupportedException中定义static Vector4D()。这至少可以告诉你到底出了什么问题：

Unhandled Exception: System.NotSupportedException: Vector4D<System.String> not supported.

Answer 2

你不能这样做，不是这样。

C＃不知道关于泛型T的任何内容。这是一个数字吗？它是一个字符串？你能用它做数学吗？

如果你想让这个工作，你必须使用通用计算器。你必须自己建造它。有关详细信息，请查看：http://www.codeproject.com/Articles/8531/Using-generics-for-calculations

更简单的解决方案可能是：

a.v1 = Convert.ChangeType(Convert.ToDecimal(a.v1) * Convert.ToDecimal(b), typeof(T));

编辑

我在另一个位置创建了一些库函数。您可以使用它在您自己的代码中实现。用这些数字计算很容易。您的Vector类将是：

partial struct Vector4D<T>
where T: IComparable<T>, IEquatable<T>
{
    public Number<T> v1;
    public Number<T> v2;
    public Number<T> v3;
    public Number<T> v4;

    public static Vector4D<T> operator *(Vector4D<T> a, T b)
    {
        a.v1 *= b;
        a.v2 *= b;
        a.v3 *= b;
        a.v4 *= b;
        return a;
    }
}

请参阅：https://codereview.stackexchange.com/questions/26022/improvement-requested-for-generic-calculator-and-generic-number

通用结构 - 如何约束类型参数C＃

2 个答案: