首页 文章

为vector类编写sort（）方法

提问于
浏览 次
3

我正在编写自己的矢量类Vector，其数据成员为：T * array，size_t vector_size和size_t capacity . 我正在尝试创建一个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 <'不匹配

c++ templates sorting vector operator-keyword

3 回答

  • 1

    您提供了具有错误签名的比较方法 . 您需要接受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;
}
    回复于
  • 1

    你忘了一个常量！

    template <class T>
bool Vector<T>::operator<(const Vector<T> & source) const // <- here
{
    return (vector_size < source.vector_size);
}
    回复于
  • 3

    您需要的一件事是在参数中使用 const 给您的运算符，否则它不能匹配任何只读的（这是常见的情况） .

    请记住，每次交换发生时，矢量排序向量都会复制整个向量 . 这不会特别有效 . 如果向量是单独存储的，并且你有像向量指针一样的向量，那么至少排序会更快 .

    一定要阅读“严格弱排序”的定义 . 排序与自身一致非常重要，或者像std :: sort（）这样的标准算法可能会出现严重错误行为（在某些实现中会破坏内存） .

    回复于

相关问题