STL

Question

this質問で列を使って二次元配列を並べ替える質問は、各ベクトルの最初の要素によるソートベクトルと各ベクトルを通り、要素で並べ替える2番目の例の良い説明を参照してください。

私は配列はSTLのパワーユーザーのためのC++の第一級オブジェクトはないことを知っているが、私は（ちょうどアンドレイ・アレキのような）アレイが好き。

ので、コードを検討することができます：

typedef int arr2D[3]; 

arr2D array2D[3] = { { 1, 4, 3 }, 
        { 9, 2, 5 }, 
        { 7, 6, 8 } }; 

std::sort(begin(array2D[2]), end(array2D[2]), greater<>()); 

この結果はこのように、降順でarray2Dの最後行を注文、次のとおりです。

1 4 3 
9 2 5 
8 7 6 <- last row by descending order 

をしかし、私が望むのは、array2Dの最後の列を降順に並べ替えることです。

平野 array S（ないベクトル）を使用して

1 4 8 
9 2 5 
7 6 3 
    ^
    └--- last column by descending order 

とstd::sort、誰かが私を助けることができますか？

はあなたがそれぞれの行の上に、特定の列の要素を反復処理するカスタムイテレータを、書くことができますあなたの

Answer 1

ありがとうございます。このような何か：

template<class Arr> 
using sub_array_t = std::remove_pointer_t<std::decay_t<Arr>>; 

template<class Arr> 
using column_iterator_base = std::iterator<std::random_access_iterator_tag, sub_array_t<sub_array_t<Arr>>>; 

template<std::size_t col_index, class Arr> 
struct column_iterator : column_iterator_base<Arr> 
{ 
    using parent = column_iterator_base<Arr>; 
    using value_type = typename parent::value_type; 
    using difference_type = typename parent::difference_type; 
    using sub_array = sub_array_t<Arr>; 

    Arr* arr; 
    sub_array* row; 

    column_iterator(Arr* arr)     : arr(arr), row(*arr) {} 
    column_iterator(Arr* arr, sub_array* row) : arr(arr), row(row) {} 

    column_iterator begin() {return {arr};} 
    column_iterator end() {return {arr, std::end(*arr)};} 

    column_iterator& operator+=(difference_type rhs) {row += rhs; return *this;} 
    column_iterator& operator-=(difference_type rhs) {row -= rhs; return *this;} 
    value_type& operator*() const {return (*row)[col_index];} 
    value_type* operator->() const {return (*row) + col_index;} 
    value_type& operator[](difference_type rhs) const {return row[rhs][col_index];} 

    column_iterator& operator++() {++row; return *this;} 
    column_iterator& operator--() {--row; return *this;} 
    column_iterator operator++(int) {column_iterator tmp(arr, row); ++row; return tmp;} 
    column_iterator operator--(int) {column_iterator tmp(arr, row); --row; return tmp;} 

    difference_type operator-(const column_iterator& rhs) const {return row-rhs.row;} 
    column_iterator operator+(difference_type rhs) const {return column_iterator(arr, row+rhs);} 
    column_iterator operator-(difference_type rhs) const {return column_iterator(arr, row-rhs);} 
    friend inline column_iterator operator+(difference_type lhs, const column_iterator& rhs) 
    {return column_iterator(rhs.arr, lhs+rhs.row);} 
    friend inline column_iterator operator-(difference_type lhs, const column_iterator& rhs) 
    {return column_iterator(rhs.arr, lhs-rhs.row);} 

    bool operator==(const column_iterator& rhs) const {return row == rhs.row;} 
    bool operator!=(const column_iterator& rhs) const {return row != rhs.row;} 
    bool operator> (const column_iterator& rhs) const {return row > rhs.row;} 
    bool operator< (const column_iterator& rhs) const {return row < rhs.row;} 
    bool operator>=(const column_iterator& rhs) const {return row >= rhs.row;} 
    bool operator<=(const column_iterator& rhs) const {return row <= rhs.row;} 
}; 

template<std::size_t col_index, class Arr> 
auto make_column_iterator(Arr* arr) 
{ 
    return column_iterator<col_index, Arr>(arr); 
} 


int main() 
{ 
    // array2D = ... 
    auto foo = make_column_iterator<1>(&array2D); 
    std::sort(foo.begin(), foo.end()); 
} 

カスタムイテレータのための定型の多くは、おそらくブーストから何かを使用することによって回避することができます。

注：これは速やかに書かれたものであり、エラーや不必要に複雑なコードが含まれている可能性があります。