std :: find（）はCスタイルの配列で後方に移動しますか？

Question

は、私がsを使用する必要が言う：

typedef struct tagSOMESTRUCT // Defined by someone else; C-compatible 
{ 
    int count; 
    int elements[256]; 
} SOMESTRUCT; 

SOMESTRUCT s; 

と私はのような機能を持っていると言う：この機能を使用するためには

template<typename RevFwdIt> 
std::pair<RevFwdIt, RevFwdIt> some_slice_rev(RevFwdIt rbegin, RevFwdIt rend) 
{ 
    RevFwdIt it = basename_rev(rbegin, rend); 
    RevFwdIt e = std::find(rbegin, it, 5); 
    return std::make_pair(e == it ? rbegin : e, it); 
} 

、私は

some_slice_rev(&s.elements[s.count - 1], &s.elements[-1]); 

どの言う必要があります（IMHO）は、off-by-oneエラーのために、醜く、エラーを起こしやすい。

一方で、私は単にそれからstd::findは終わりの代わりに最初から検索してしまうため（より良い）

some_slice(&s.elements[0], &s.elements[s.count]); 

を使用するsome_sliceにsome_slice_revを変更することはできません。

一方、std::findが未処理のポインタである「逆イテレータ」をどのように処理するのかわからないので、コード自体はすでに壊れています。

このような状況でコードを修正する最もよい方法は何ですか？ rawポインタである逆イテレータを扱う方法はありますか？または、これを修正するための標準的なリファクタリングメカニズムがありますか？以外はSOMESTRUCTを変更していますか？

Answer 1

は（それはあなたが避けるようにしようとしているように見えるイテレータ方向の厄介な混合からのものであってもよい）が、私はちょうどstd::reverse_iteratorにあなたの注意を向けましょう：

#include <iostream> 
#include <iterator> 

// for example 
template <typename Iter> 
void print_it(Iter first, Iter last) 
{ 
    std::cout << '|'; 

    for (; first != last; ++first) 
     std::cout << ' ' << *first << " |"; 

    std::cout << std::endl; 
} 

int main() 
{ 
    int arr[10] = {1, 2, 3, 4}; 

    int *begin = arr, *end = arr + 4; 

    print_it(begin, end); 
    print_it(std::reverse_iterator<int*>(end), 
       std::reverse_iterator<int*>(begin)); 
} 

++が内部では--であることを除いて、双方向イテレータのように機能し、その逆もあります。

これはちょっと醜いことに注意してください。あなたは、いくつかのユーティリティ機能をお勧めします：

#include <iostream> 
#include <iterator> 

// for example 
template <typename Iter> 
void print_it(Iter first, Iter last) 
{ 
    std::cout << '|'; 

    for (; first != last; ++first) 
     std::cout << ' ' << *first << " |"; 

    std::cout << std::endl; 
} 

template <typename Iter> 
std::reverse_iterator<Iter> make_reverse_iterator(Iter iter) 
{ 
    return std::reverse_iterator<Iter>(iter); 
} 

int main() 
{ 
    int arr[10] = {1, 2, 3, 4}; 

    int *begin = arr, *end = arr + 4; 

    print_it(begin, end); 
    print_it(make_reverse_iterator(end), 
       make_reverse_iterator(begin)); 
} 

---

だから私はあなたがこのほしいと思う：今比較的オフトピック

template<typename ForwardIterator > 
std::pair<ForwardIterator, ForwardIterator> 
    some_slice(ForwardIterator begin, ForwardIterator end) 
{ 
    typedef std::reverse_iterator<ForwardIterator> rev_iter; 

    rev_iter it = basename(rev_iter(end), rev_iter(begin)); 
    rev_iter e = std::find(rev_iter(end), it, 5); 

    return std::make_pair(it.base(), e.base()); 
} 

---

を、しかしs.countがある場合s.elements[s.count]は未定義の動作であることに注意してください256、s.elements[s.count]が*(s.elements + s.count)であるため、逆参照する有効な配列要素ではありません。実際に

、&*xはxに相殺するので、完全な表現は結構ですが、あなたはおそらくまだそれを回避したい：私は厳密にそれはあるかもしれない話すと思うけれども

some_slice(s.elements, s.elements + s.count); 

s.elements[-1]も、未定義の動作かもしれアレイの前にintのメンバーがあるため、偶発的に合法的になりました。

Answer 2

リバースイテレータをシミュレートするためにラッパーイテレータクラスを記述してから、生の配列イテレータの代わりにstd::findを使用するのが簡単な解決策です。したがって、std::findが++itを呼び出すと、operator++が呼び出され、実際には実際のイテレータである--rawItがデクリメントされます。それが他の標準的なリバース・イテレータの機能です。私は質問を理解し、非常にわからないんだけど