C# 对类层次结构中显式类型转换的必要性的混淆

本文关键字：类型转换 必要性 层次结构 | 更新日期: 2023-09-27 17:58:55

我有两个类Vector和Point，其中Point是Vector的子类。我有一个Scale Vector s的方法(因此也适用于Point s(和一个返回深层副本的Point s的方法Clone。

public class Vector
{
    protected double x, y, z;
    public Vector(double x, double y, double z)
    {
        this.x = x; this.y = y; this.z = z;
    }
    public Vector Scale(double sc)
    {
        this.x = sc * x; this.y = sc * y; this.z = sc * z;
        return this;
    }
}
public class Point : Vector
{
    public Point(double x, double y, double z) : base(x, y, z) { }
    public Point Clone()
    {
        return new Point(this.x, this.y, this.z);
    }
}

(注意：实际代码比这更复杂，方法更多，但这段摘录应该足以说明问题。请不要建议对继承层次结构进行任何更改或将类转换为结构。我已经和我的同事一起评估了这些问题。

现在我将以下内容写入我的主程序：

Point p = new Point(1, 2, 3);
Point q = p.Clone().Scale(2); // compile error complaining about missing cast

第二行可以通过以下方式修复：

Point q = p.Clone().Scale(2) as Point;

但我的问题是我不明白为什么这是必要的。这就是我认为编译器所做的：

p是一个Point. p.Clone()是另一个Point.我们检查是否存在方法Point.Scale(double) .我们找不到，所以我们检查超类是否有这样的方法，即是否存在Vector.Scale(double)方法。我们调查Vector.Scale，发现它返回this 。由于p.Clone()是一个Point，我们知道p.Clone().Scale(2)的返回值会自己p.Clone()(但被修改(，所以它一定是一个Point。瞧，无需施法。

  • 那么问题出在哪里，为什么编译器不能推断我不需要任何强制转换呢？
  • 如何修复它，使用户不必每次都进行转换？实现此目的的唯一方法是编写方法Point.Scale(double)吗？我知道我可以通过重定向到Vector.Scale(double)来使其成为单行，但由于新方法的额外文档注释，我将产生额外费用，因此这是不可取的。
  • 这种强制转换只是一种形式主义，使编译器不会抱怨，还是内部实际上会做任何事情？我的意思是像移动内存或分配/解除分配内存或任何计算之类的事情？

C# 对类层次结构中显式类型转换的必要性的混淆

这是因为推断的类型是上次执行的函数的返回类型(最右边的函数，或者您在这种情况下返回Vector而不是Point的Scale()方法(

若要不必在每次调用缩放方法时都强制转换，可以使用泛型。

一个例子是：

public abstract class Scalable<T>
{
    protected double x, y, z;
    public T Scale(double sc)
    {
        this.x = sc * x; this.y = sc * y; this.z = sc * z;
        return this;
    }
    public Scalable(double x, double y, double z)
    {
        this.x = x; this.y = y; this.z = z;
    }
}
该类

将定义使对象可扩展所需的内容，它被定义为抽象的，以便开发人员无法创建该类的实例，只能从中继承。

然后，您的其他两个类将相应地更改：

public class Vector : Scalable<Vector>
{
    public Vector(double x, double y, double z) : base(x,y,z)
    {
    }
}

和 

public class Point : Scalable<Point>
{
    public Point(double x, double y, double z) : base(x, y, z) { }
    public Point Clone()
    {
        return new Point(this.x, this.y, this.z);
    }
}

另一种更简单的方法很简单，就是定义一个 scale 方法，该方法调用 Vector one 并一次性投射：

public class Point : Vector
{
    public Point(double x, double y, double z) : base(x, y, z) { }
    public Point Clone()
    {
        return new Point(this.x, this.y, this.z);
    }
    public Point Scale(double sc)
    {
        return (Point)base.Scale(sc);
    }
}

对于你的第三个问题：

编译器不知道你在方法中做什么，它只知道返回什么类型。

因此，它不能保证返回的对象可以转换为Point对象。

你必须写的演员表在这里告诉编译器："别担心，我知道这个对象是我指示你的类型">

Scale 方法返回一个 Vector 对象。不能将矢量对象指定给点参照。点继承自矢量。

此外，我建议您使用结构而不是类。然后，您将不需要克隆方法。

您可以将Scale的返回类型更改为dynamic(取决于编译器的可用性(：

public dynamic Scale(double sc)
{
    this.x = sc * x; this.y = sc * y; this.z = sc * z;
    return this;
}

有关问题，请参阅下面的评论。

相关文章：