主页 / 问题 / 570778
Accepted
Anton Tregubenkov
Asked:2020-09-27 13:42:31 +0000 UTC2020-09-27 13:42:31 +0000 UTC

如何使 3 个构造函数具有相同的签名？

  • 772

我们需要编写一个包含该类的程序Triangle。这个类应该有三个构造函数：

  1. 接受三个边的构造函数。
  2. 一个构造函数，它取两条边和它们之间的角度，并使用余弦定理计算第三条边。
  3. 一个构造函数，它取两个角和它们之间的一条边，并使用正弦定理（记住三角形角和定理）计算剩余的边。

每个Triangle人还必须返回自己的区域。

也就是说，我们有以下内容： 

class Triangle
{
    Triangle(double side1, double side2, double side3)
    {
    }
    Triangle(double side1, double side2, double angle)
    {
    }
    Triangle(double side1, double angle1, double angle2)
    {
    }
}

整个问题是所有三个构造函数都具有相同的签名，但逻辑不同。
问题：如何“正确”解决这个问题？

“错误”选项：

  1. 用 替换参数并 double进一步string解析string。double
  2. double用替换参数float。

  3. 将参数传输到数组： 

    Triangle(double[] sides, double angle)
  4. 创建新的数据类型Angle。
c#

4 个回答

  1. Best Answer

    选项 1 - 使用命名构造函数。

    命名构造函数是一种静态方法，其任务是创建具有给定参数的对象。有时它们仍不能完全正确地称为工厂方法。

    class Triangle
{
    private Triangle() {}

    public static Triangle From3Sides(double side1, double side2, double side3) { ... }

    public static Triangle From2SidesAndAngle(double side1, double side2, double angle) { ... }

    public static Triangle FromSideAnd2Angles(double side, double angle1, double angle2) { ... }
}

    选项 2 - 使用域数据类型

    我们定义数据类型“长度”和“角度”——并在构造函数中使用它们。

    class Length
{
  public double Value { get; }

  public Length() {}
  public Length(double value) { Value = value; }

  public static implicit operator double (Length length)
    => length.Value;
  public static implicit operator Length (double value)
    => new Length(value);
}

class Angle
{
  public double Value { get; }

  public Angle() {}
  public Angle(double value) { Value = value; }

  public static implicit operator double (Angle angle)
    => angle.Value;
  public static implicit operator Angle (double value)
    => new Angle(value);
}
    • 18

  2. 作为一个选项，将参数集分组为结构：

    public struct ThreeSides
{
    double side1;
    double side2;
    double side3;
}
public struct TwoSidesAndAngle
{
    double side1;
    double side2;
    double angle;
}
public struct SideAndTwoAngles
{
    double side1;
    double angle1;
    double angle2;
}

public class Triangle
{
    public Triangle(ThreeSides params)
    {
    }

    public Triangle(TwoSidesAndAngle params)
    {
    }

    public Triangle(SideAndTwoAngles params)
    {
    }
}

    但在我看来，Pavel 的回答是工厂更正确的选择

    • 4

  3. 已经建议的几个替代方案。

    因为 重载函数（包括构造函数）的选择是基于类型的，显然创建多个具有相同签名的不同构造函数是行不通的。

    这个问题可以通过添加一个额外的参数来解决。

    1. 创建了新的“空”类（名称取自@Argon 的回答）：

      class ThreeSides {}
class TwoSidesAndAngle {}
class SideAndTwoAngles {}

      这种情况下的构造函数签名如下：

      Triangle(double side1, double side2, double side3, ThreeSides unused);
Triangle(double side1, double side2, double angle, TwoSidesAndAngle unused);
Triangle(double side1, double angle1, double angle2, SideAndTwoAngles unused);

    2. 使用枚举enum。

      enum Kind { ThreeSides, TwoSidesAndAngle, SideAndTwoAngles }

      在这种情况下，构造函数将是唯一一个内部有逻辑分支的构造函数：

      Triangle(double arg1, double arg2, double arg3, Kind kind);

      在这种情况下，kind如果计划采用一种或另一种构建三角形的变体，则可以将参数设置为默认值。例如：

      Triangle(double arg1, double arg2, double arg3, Kind kind = Kind.ThreeSides);
    • 1

  4. 如果你愿意，你可以这样做：

    http://ideone.com/XLf5Pz

    using System;

class Triangle
{
    public struct NeverCreateMe {}

    public Triangle(double side1, double side2, double side3)
    {
        Console.WriteLine("3 sides");
    }

    public Triangle(double side1, double side2, NeverCreateMe ignored = default(NeverCreateMe), double angle = 0)
    {
        Console.WriteLine("2 sides and 1 angle");
    }

    public Triangle(double side1, NeverCreateMe ignored = default(NeverCreateMe), double angle1 = 0, double angle2 = 0)
    {
        Console.WriteLine("1 side and 2 angles");
    }
}

public class Test
{
    public static void Main()
    {
        var a = new Triangle(1.0, 2.0, 3.0);
        var b = new Triangle(1.0, 2.0, angle: 3.0);
        var c = new Triangle(1.0, angle1: 2.0, angle2: 3.0);
    }
}

    甚至这样：

    http://ideone.com/VEGn2s

    using System;

class Triangle
{
    public struct NeverCreateMe<T> {}

    public Triangle(double side1, double side2, double side3)
    {
        Console.WriteLine("3 sides");
    }

    public Triangle(double side1, double side2, double angle, NeverCreateMe<bool> ignored = default(NeverCreateMe<bool>))
    {
        Console.WriteLine("2 sides and 1 angle");
    }

    public Triangle(double side1, double angle1, double angle2, NeverCreateMe<int> ignored = default(NeverCreateMe<int>))
    {
        Console.WriteLine("1 side and 2 angles");
    }
}

public class Test
{
    public static void Main()
    {
        var a = new Triangle(1.0, 2.0, 3.0);
        var b = new Triangle(1.0, 2.0, angle: 3.0);
        var c = new Triangle(1.0, angle1: 2.0, angle2: 3.0);
    }
}

    每种方法都有其优点和缺点，但如果需要，可以解决它们。

    • 0

相关问题