3

我正在编写自己的向量类 Vector，其中包含以下数据成员：T* 数组、size_t vector_size 和 size_t 容量。我正在尝试创建一个 sort() 方法：

template <class T>                                                                                                 
void Vector<T>::sort(bool ascending)                                                                                 
{                                                                                                                   
    std::sort(array,array+vector_size);                                                                              
    if(ascending==false)                                                                                             
        std::reverse(array,array+vector_size);                                                                      
}

当数组中的元素是 int、char 等类型时，它可以正常工作。但是当我尝试对由 Vector 元素组成的向量进行排序时，它不会编译。根据我的阅读，我需要以<某种方式定义运算符，但我真的不知道该怎么做......

我努力了：

template <class T>
bool Vector<T>::operator<(Vector<T> & source) const
{
    return (vector_size < source.vector_size);
}

我的主要外观是这样的：

int main() {
    Vector<int> v1(5,1);
    Vector<int> v2(7,2);
    Vector<int> v3(3,3);
    Vector<Vector<int>> v4;
    v4 = {v1,v2,v3};
    v4.sort(1);
return 0;
}

这是我得到的错误之一：

/usr/include/c++/4.6/bits/stl_algo.h:2212:4：错误：'* __first < __pivot'中的'operator<'不匹配</p>

4

3 回答 3

3

您提供了带有错误签名的比较方法。您需要接受 const 引用或值，但不是对您的类型的（可修改）引用，而前者应该是首选，除非它是原始类型。因此，您的比较方法的签名应如下所示：

template <class T>
bool Vector<T>::operator<(const Vector<T> & source) const
{
    return (vector_size < source.vector_size);
}

这是因为std::sort（以及许多其他方法）旨在不修改内容。如果它们采用值（但对于大型类型来说这会很慢）或 const 引用，则可以保证这一点。

请注意，您定义了比较方法来比较向量的大小，而不是它们的内容。你所有的向量都是等长的。因此它们被视为相等std::sort。所以std::sort不会改变v4...如果您打算以类似于字符串比较的方式比较内容（第一个条目首先计数，如果相等则取下一个，依此类推...），请使用：

template <class T>
bool Vector<T>::operator<(const Vector<T> & source) const
{
    for(int i = 0; i < size && i < source.size; ++i) {
        if(*this[i] < source[i])
            return true;
        else if(source[i] < *this[i])
            return false;
    }
    // You have to decide what to do if the length isn't equal.
    // But if the vectors are really equal than return false:
    if(size == source.size)
        return false;
}
于 2012-09-30T15:35:01.507 回答
1

你忘了一个常量！

template <class T>
bool Vector<T>::operator<(const Vector<T> & source) const // <- here
{
    return (vector_size < source.vector_size);
}
于 2012-09-30T15:34:57.263 回答
1

您需要的一件事是const在参数中使用运算符，否则它无法匹配任何只读的内容（这将是常见情况）。

请记住，尽管每次交换发生时对向量的向量进行排序都会复制整个向量。这不会特别有效。如果向量是分开存储的，并且你有类似向量的指针到向量的东西，至少排序会更快。

请务必阅读“严格弱排序”的定义。排序与自身保持一致非常重要，否则标准算法（如 std::sort() 可能会出现严重的错误行为（在某些实现中会破坏内存））。

于 2012-09-30T15:39:03.403 回答