Question

我曾尝试使用IComparable并进行了研究，但我无法弄清楚为什么这不起作用。我想比较字符串和整数但我不明白如何使用ICompareable接口对一类Generic进行compareTo。

如何实现CompareTo来处理泛型？

enum From { from };
enum To { to };
enum To_before { to_before };

class Sequence
{
private:
    int first_;
    int after_;
    int delta_;

public:
    class Iter
    {
    friend class Sequence;
    private:
        Sequence const* p_seq_;
        int             current_;

        Iter( Sequence const& seq )
            : p_seq_( &seq )
            , current_( seq.first_ )
        {}

        Iter( Sequence const& seq, int const current )
            : p_seq_( &seq )
            , current_( current )
        {}

    public:
        friend auto operator==( Iter const& a, Iter const& b )
            -> bool
        { return a.current_ == b.current_; }        // UB if not same sequence.

        friend auto operator!=( Iter const& a, Iter const& b )
            -> bool
        { return a.current_ != b.current_; }

        auto operator*() const
            -> int
        { return current_; }

        auto operator++()
            -> Iter&
        {
            current_ += p_seq_->delta_;
            return *this;
        }

        auto operator++( int )
            -> Iter
        {
            Iter result{ *this };
            current_ += p_seq_->delta_;
            return result;
        }
    };

    auto begin() const -> Iter { return Iter{ *this }; }
    auto end() const -> Iter { return Iter{ *this, after_ }; }

    Sequence( int const first, int const last, bool inclusive = true )
        : first_( first )
        , after_( last )
        , delta_( first <= last? 1 : -1 )
    { if( inclusive ) { after_ += delta_; } }

    Sequence( From, int const first, To, int const last )
        : Sequence( first, last, true )
    {}

    Sequence( From, int const first, To_before, int const last )
        : Sequence( first, last, false )
    {}
};

#include <iostream>
using namespace std;

auto main()
    -> int
{
    using Seq = Sequence;
    for( int const i : Seq{ from, 10, to, 15 } ) { cout << i << ' '; }
    cout << endl;
    for( int const i : Seq{ from, 15, to, 10 } ) { cout << i << ' '; }
    cout << endl;
    cout << endl;
    for( int const i : Seq{ from, 10, to_before, 15 } ) { cout << i << ' '; }
    cout << endl;
    for( int const i : Seq{ from, 15, to_before, 10 } ) { cout << i << ' '; }
    cout << endl;
}

Answer 1

您必须指定可以比较T，编译器无法知道该类型。这样您就可以使用CompareTo来满足您的条件：

public class QuickSort
{
    public static int Partition<T>(T[] arr, int lo, int hi) where T : IComparable
    {
        int i = lo + 1;
        int j = hi;
        while (j > i)
        {
            while (arr[i].CompareTo(arr[lo]) == 0)
                i++;
            while (arr[j].CompareTo(arr[lo]) > 0) // means arr[j] > arr[lo]
                j--;

            Swap(ref arr[i], ref arr[j]);
        }

        Swap(ref arr[lo], ref arr[j]);

        return j;
    }
}

另外，我不认为你想要比较不同的QuickSort实例，所以我删除了它的界面。

更新：根据Hawkmooon的评论，我再次看了一下你的方法，并认为它的签名可以更简单：

    public static int Partition(IComparable[] arr, int lo, int hi)
    {
        int i = lo + 1;
        int j = hi;
        while (j > i)
        {
            while (arr[i].CompareTo(arr[lo]) == 0)
                i++;
            while (arr[j].CompareTo(arr[lo]) > 0)
                j--;

            Swap(ref arr[i], ref arr[j]);
        }

        Swap(ref arr[lo], ref arr[j]);

        return j;
    }

我认为你的代码可能遗漏了一些东西。以防万一，{{3}}。

Answer 2

您需要明确指定T实施IComparable。将方法的声明更改为：

public static int Partition<T>(ref T[] arr, int lo, int hi) where T : IComparable

此外，您无法比较arr[i] > arr[j]之类的商品。你需要调用CompareTo()并检查它是否大于零，小于零或等于零：

while(arr[i].CompareTo(arr[high]) > 0)

（这意味着您的情况为arr[i] > arr[high]。）

您很可能不需要在IComparable课程上实施QuickSort。需要为那些将要比较的项目实现IComparable，而不是比较器类本身。

如何比较Strings＆amp;通用中的int使用可比较的C＃

2 个答案: