C# 函数中数组参数长度的默认参数值

我制作了一个函数，该函数对通过传递给函数的数组进行快速排序，但由于该函数是递归函数，因此需要两个额外的参数来帮助快速排序。 在每一轮函数之后，它将左或右设置为下一个要排序的区域，以此类推

由于这些额外的参数，每次我手动调用函数进行快速排序时，我需要添加0和数组长度作为参数

   Quicksort(arr,0,arr.Length);

现在，这似乎是可以避免的，但只需向左参数（0）添加一个默认值，但右参数需要是数组的长度，在这种情况下称为元素，它将是：

   public static void QuickSort<T>(T[] elements, int left = 0, int right = elements.Length) where T : IComparable

publicstaticvoidquicksort（T[]个元素，int left=0，int right=elements.Length），其中T:IComparable

但是获取元素数组的长度是不可能的

我想做一个函数，它可以代替我简单地插入0和数组的长度，但我想找到一种方法，如果可能的话，不需要额外的函数。提前感谢：）

publicstaticvoidquicksort（T[]元素，int left，int right），其中T:IComparable
{
int i=左，j=右；
T轴=元素[（左+右）/2]；
而(i 0)
j--；
如果（i有时最简单的解决方案是最好的：添加一个重载

public static void QuickSort<T>(T[] elements, int left = 0) where T : IComparable
{
    QuickSort(elements, left, elements.Length);
}

public static void QuickSort<T>(T[] elements, int left, int right) where T : IComparable
{
    // code
}

更丑陋的解决方案（使用-1作为“要替换的值”）-1（或
int.MinValue
）不是
权利的法律领域的一部分，但此解决方案非常丑陋：-）

publicstaticvoidquicksort（T[]元素，int-left=0，int-right=-1），其中T:IComparable
{
如果（右==-1）
{
右=元素。长度；
}
//代码
}
由于您总是将数组本身作为第一个参数发送，因此您仍然拥有长度。如果您可以从第一个参数获取数组的长度，那么为什么还要发送长度呢

换句话说，稍微修改一下代码，这样每次对快速排序的调用都只通过一个数组发送。根本不要左右发送。将每次调用中得到的数组拆分，然后将拆分后的数组发送到两个子快速排序调用，而不必每次都左右发送。
您需要一个具有漂亮、干净、最小签名的方法来扩展ose提供给外部世界和一个私有递归方法来进行排序

因此：

//此方法对外公开。
//没有人需要知道“左”和“右”。
//此方法的使用者只想对某些元素进行“快速排序”。
公共静态void快速排序（T[]元素），其中T:IComparable
{
//在这里初始化递归，然后忘记它
QuickSortInternal（元素，0，元素.长度）；
}
//这是您的递归方法
私有静态void QuickSortInternal（T[]元素，int left，int right），其中T:IComparable
{
//你的代码。。。。
}
这正是我想要避免的，但谢谢anyways@SuperMinefudge在C++中，你可以把任何东西作为函数的默认值。在C语言中你不能。你只能使用在编译时已知的值。因为递归不会每次都在代码中看到数组长度。我会尝试。我想了想，重点是。快速排序的方法是发送排序后的数组，所以将其拆分是否意味着我必须将其重新组合在一起这是一件痛苦的事情？是的。您必须将其重新组合在一起。不仅如此，它的效率也会降低，因为您也将动态创建数组。因此问题变成了，更糟糕的是什么？这样做，还是仅仅使用重载？
public static void QuickSort<T>(T[] elements, int left = 0) where T : IComparable
{
    QuickSort(elements, left, elements.Length);
}

public static void QuickSort<T>(T[] elements, int left, int right) where T : IComparable
{
    // code
}

public static void QuickSort<T>(T[] elements, int left = 0, int rightTemp = null) where T : IComparable
{
    int right = rightTemp ?? elements.Length;

    // code
}

public static void QuickSort<T>(T[] elements, int left = 0, int right = -1) where T : IComparable
{
    if (right == -1)
    {
        right = elements.Length;
    }

    // code
}

// this method is exposed to the outside world.
// Nobody needs to know about "left" and "right".
// Consumers of this method just want to "QuickSort" some elements. 
public static void QuickSort<T>(T[] elements) where T : IComparable
{
    // init the recursion here and forget about it
    QuickSortInternal(elements, 0 , elements.Length);
}

// this is your recursive method
private static void QuickSortInternal<T>(T[] elements, int left, int right) where T : IComparable
{
    // your code....
}