Question

我有一个2D数组a[][40]。我试图通过调用std::sort对其进行排序，并编写了Compare函数。但是，C++希望我对std::vector进行排序，而不是简单的数组，我希望排序的数组本身为a，我不想创建另一个数组并保存排序结果。似乎有很多方法可以实现这一目标。我可以想到五种方式，但它们似乎都没有效率和工作。

1）

直接使用std::sort(std::begin(a), std::begin(a) + something, cmp);

它不起作用，因为std::begin不知道如何指向2D数组的开头。此外，即使编译它也不正确排序，因为2D数组不是对数组的引用数组，而是连续数组（与Java不同）

游乐场：https://godbolt.org/g/1tu3TF

2）

std::vector<unsigned char[40]> k(a, a + x);
std::sort(k.begin(), k.end(), cmp);

然后将所有内容复制回a

它不起作用，因为它是一个2D数组，并且无法使用std::sort以这种方式对其进行排序。与第一次试验相比，这个使用的内存是内存的两倍，并将所有内容复制两次（如果有效）！

游乐场：https://godbolt.org/g/TgCT6Z

3）

std::vector<int> k(x);
for (int i = 0; i < x; k[i] = i, i++);
std::sort(k.begin(), k.end(), cmp2);
然后将a的顺序更改为k的顺序;

这个想法很简单，创建一个代表性的指针＆＃34;指针＆＃34;，对它们进行排序（因为cmp2函数秘密访问a并比较值），然后制作a与k具有相同的订单。

最后，重新排序循环将非常复杂，需要一个大的临时变量。此外，要cmp2访问a的值，必须创建一个指向a的全局变量指针，这是＆＃34; bad＆＃34;代码。

游乐场：https://godbolt.org/g/EjdMo7

4）

对于所有unsigned char[40]，可以创建结构并将其值复制到结构。需要声明比较和=运算符。排序后，可以将它们复制回a。

如果不必将数组复制到结构以使用struct的运算符，那么它是一个很好的解决方案，但它们需要被复制，因此所有值都将被复制两次，将使用两次所需的内存。

5）

对于所有unsigned char[40]，可以创建具有指向它们的指针的结构。它们可以按指向的值排序，结果可以保存到指针数组中。

它可能是最好的选择，虽然结果是指针数组而不是a。它之所以好的另一个原因是它不会移动数组，而是指针。

总而言之，我需要通过a[][40]对2D数组std::sort进行排序，但我还没有确定最好的方法。似乎有一个＆＃34;最好的方法来做到这一点＆＃34;这是我无法想到的。你能帮我吗？

编辑：为了澄清，我希望{{3,2}{1,4}}成为{{1,4}{3,2}}

Answer 1

问题不在于迭代2D数组。如果列大小是constexpr值，则指向数组的指针是很好的迭代器。

但是所有C ++排序（或变异）算法都要求底层类型可移动构造并移动可分配，并且数组不可分配。但是包装底层数组就足够了：

template <class T, int sz>
class wrapper {
    T* base;
    bool own;            // a trick to allow temporaries: only them have own == true
public:
    // constructor using a existing array
    wrapper(T* arr): base(arr), own(false) {}

    ~wrapper() {              // destructor
        if (own) {
            delete[] base;    // destruct array for a temporary wrapper
        }
    }
    // move constructor - in fact copy to a temporary array
    wrapper(wrapper<T, sz>&& src): base(new T[sz]), own(true) {
        for(int i=0; i<sz; i++) {
            base[i] = src.base[i];
        }
    }
    // move assignment operator - in fact also copy
    wrapper<T, sz>& operator = (wrapper<T, sz>&& src) {
        for(int i=0; i<sz; i++) {
            base[i] = src.base[i];
        }
        return *this;
    }
    // native ordering based on lexicographic string order
    bool operator < (const wrapper<T, sz>& other) const {
        return std::char_traits<char>::compare(base, other.base, sz) < 0;
    }
    const T* value() const {    // access to the underlying string for tests
        return base;
    }
};

然后，您可以使用任何C ++排序算法对C兼容的2D阵列进行排序：

std::vector<wrapper<char, 40> > v { &arr[0], &arr[sz] };  // pointer are iterators...
std::sort(v.begin(), v.end());                            // and that's all!

for (int i=0; i<sz; i++) {                                // control
    std::cout << arr[i] << std::endl;
}

开销是包含指针和bool的结构向量，但是排序的实际上是原始的2D数组。

当然，由于可以从C ++访问C库，qsort对于C兼容的2D数组进行排序肯定会更容易。但是，这种方式允许使用stable_sort或partial_sort，如果它们相关的话。

通过std :: sort

1 个答案: