STLスタイルの反復子を実装して一般的な落とし穴を回避する方法
私はSTLスタイルのランダムアクセスイテレータを提供したいコレクションを作りました。イテレータの実装例を探していましたが、見つかりませんでした。私は[]と*演算子のconstオーバーロードの必要性について知っています。 「STLスタイル」であるための反復子の要件は何ですか？（もしあれば）避けるべきその他の落とし穴は何ですか？
追加の文脈：これは図書館のためのものです。私が本当に必要としているのでなければ、私はそれへの依存を紹介したくありません。私はC++ 03とC++ 11の間のバイナリ互換性を同じコンパイラで提供できるように私自身のコレクションを書いています（だから壊れるSTLはありません）。
http://www.cplusplus.com/reference/std/iterator/ はC++ 11標準の§24.2.2の仕様を詳述した便利な図表を持っています。基本的に、イテレータには有効な操作を記述するタグがあり、タグには階層があります。以下は純粋に象徴的なものです。これらのクラスは実際にはそのように存在しません。
iterator {
iterator(const iterator&);
~iterator();
iterator& operator=(const iterator&);
iterator& operator++(); //prefix increment
reference operator*() const;
friend void swap(iterator& lhs, iterator& rhs); //C++11 I think
};
input_iterator : public virtual iterator {
iterator operator++(int); //postfix increment
value_type operator*() const;
pointer operator->() const;
friend bool operator==(const iterator&, const iterator&);
friend bool operator!=(const iterator&, const iterator&);
};
//once an input iterator has been dereferenced, it is
//undefined to dereference one before that.
output_iterator : public virtual iterator {
reference operator*() const;
iterator operator++(int); //postfix increment
};
//dereferences may only be on the left side of an assignment
//once an output iterator has been dereferenced, it is
//undefined to dereference one before that.
forward_iterator : input_iterator, output_iterator {
forward_iterator();
};
//multiple passes allowed
bidirectional_iterator : forward_iterator {
iterator& operator--(); //prefix decrement
iterator operator--(int); //postfix decrement
};
random_access_iterator : bidirectional_iterator {
friend bool operator<(const iterator&, const iterator&);
friend bool operator>(const iterator&, const iterator&);
friend bool operator<=(const iterator&, const iterator&);
friend bool operator>=(const iterator&, const iterator&);
iterator& operator+=(size_type);
friend iterator operator+(const iterator&, size_type);
friend iterator operator+(size_type, const iterator&);
iterator& operator-=(size_type);
friend iterator operator-(const iterator&, size_type);
friend difference_type operator-(iterator, iterator);
reference operator[](size_type) const;
};
contiguous_iterator : random_access_iterator { //C++17
}; //elements are stored contiguously in memory.
std::iterator_traits<youriterator>を特殊化するか、同じtypedefをイテレータ自体に入れるか、std::iterator（これらのtypedefを持つ）から継承することができます。 std名前空間の変更を避け、読みやすくするために、2番目のオプションをお勧めしますが、ほとんどの人はstd::iteratorを継承しています。
struct std::iterator_traits<youriterator> {
typedef ???? difference_type; //almost always ptrdiff_t
typedef ???? value_type; //almost always T
typedef ???? reference; //almost always T& or const T&
typedef ???? pointer; //almost always T* or const T*
typedef ???? iterator_category; //usually std::forward_iterator_tag or similar
};
Iterator_categoryは、イテレータがどの要件を満たすかに応じて、std::input_iterator_tag、std::output_iterator_tag、std::forward_iterator_tag、std::bidirectional_iterator_tag、またはstd::random_access_iterator_tagのいずれかにする必要があります。イテレータによっては、std::next、std::prev、std::advance、およびstd::distanceの特殊化を選択することもできますが、これはほとんど必要ありません。 非常にまれなケースでは、std::beginとstd::endを特殊化したいと思うかもしれません。
おそらくあなたのコンテナもconst_iteratorを持っているべきです。これはiteratorから暗黙的に構築可能であるべきでユーザーがデータを変更できないはずであることを除いてあなたのiteratorに似た定数データへの（おそらく変更可能な）イテレータです内部ポインタが非定数データへのポインタであり、コードの重複を最小限に抑えるためにiteratorをconst_iteratorから継承することが一般的です。
私の投稿 あなた自身のSTLコンテナを書く はより完全なコンテナ/イテレータのプロトタイプを持っています。
Boost.Iteratorからの iterator_facadeドキュメント は、リンクリストのためのイテレータ実装に関する素晴らしいチュートリアルのようなものを提供します。コンテナ上でランダムアクセスイテレータを構築するための出発点としてそれを使用できますか？
それ以外の場合は、iterator_facadeによって提供されるメンバ関数とtypedefを見て、それを自分で構築するための出発点として使用できます。
Thomas Beckerがこのテーマ に関する有用な記事をここに書いています 。
SOで以前に登場したこの（おそらくより単純な）アプローチもありました： カスタムイテレータとconst_iteratorsを正しく実装する方法？
これは生のポインタイテレータのサンプルです。
生のポインタを扱うためにイテレータクラスを使うべきではありません！
#include <iostream>
#include <vector>
#include <list>
#include <iterator>
#include <assert.h>
template<typename T>
class ptr_iterator
: public std::iterator<std::forward_iterator_tag, T>
{
typedef ptr_iterator<T> iterator;
pointer pos_;
public:
ptr_iterator() : pos_(nullptr) {}
ptr_iterator(T* v) : pos_(v) {}
~ptr_iterator() {}
iterator operator++(int) /* postfix */ { return pos_++; }
iterator& operator++() /* prefix */ { ++pos_; return *this; }
reference operator* () const { return *pos_; }
pointer operator->() const { return pos_; }
iterator operator+ (difference_type v) const { return pos_ + v; }
bool operator==(const iterator& rhs) const { return pos_ == rhs.pos_; }
bool operator!=(const iterator& rhs) const { return pos_ != rhs.pos_; }
};
template<typename T>
ptr_iterator<T> begin(T *val) { return ptr_iterator<T>(val); }
template<typename T, typename Tsize>
ptr_iterator<T> end(T *val, Tsize size) { return ptr_iterator<T>(val) + size; }
生ポインタ範囲ベースのループ回避策。生のポインタから範囲ベースのループを作成するためのより良い方法がある場合は、修正してください。
template<typename T>
class ptr_range
{
T* begin_;
T* end_;
public:
ptr_range(T* ptr, size_t length) : begin_(ptr), end_(ptr + length) { assert(begin_ <= end_); }
T* begin() const { return begin_; }
T* end() const { return end_; }
};
template<typename T>
ptr_range<T> range(T* ptr, size_t length) { return ptr_range<T>(ptr, length); }
そして簡単なテスト
void DoIteratorTest()
{
const static size_t size = 10;
uint8_t *data = new uint8_t[size];
{
// Only for iterator test
uint8_t n = '0';
auto first = begin(data);
auto last = end(data, size);
for (auto it = first; it != last; ++it)
{
*it = n++;
}
// It's prefer to use the following way:
for (const auto& n : range(data, size))
{
std::cout << " char: " << static_cast<char>(n) << std::endl;
}
}
{
// Only for iterator test
ptr_iterator<uint8_t> first(data);
ptr_iterator<uint8_t> last(first + size);
std::vector<uint8_t> v1(first, last);
// It's prefer to use the following way:
std::vector<uint8_t> v2(data, data + size);
}
{
std::list<std::vector<uint8_t>> queue_;
queue_.emplace_back(begin(data), end(data, size));
queue_.emplace_back(data, data + size);
}
}
まず第一にあなたは個々のイテレータ型がサポートする必要がある様々な操作のリストについて ここ を見ることができます。
次に、イテレータクラスを作成したら、 std::iterator_traits を特殊化して必要なtypedefs（iterator_categoryやvalue_typeなど）を指定するか、または std::iterator から派生させる必要があります必要なtypedefsを定義しているので、デフォルトのstd::iterator_traitsと共に使用できます。
免責事項：cplusplus.comがそれほど好きではないという人もいますが、彼らはこれに関して本当に役に立つ情報を提供しています。
私はあなたと同じ船にいたのですが、理由はいくつかあります（部分的には教育、部分的には制約）。私は標準ライブラリのすべてのコンテナを書き直さなければならず、コンテナは標準に準拠しなければなりませんでした。つまり、stlバージョンとコンテナを交換しても、コードは同じように機能します。それはまた、私はイテレータを書き直さなければならなかったことを意味しました。
とにかく、私は EASTL を見ました。私がstlコンテナを使って、または私の学部課程を通してこれまでずっと学んだことがないコンテナについてのトンを学ぶことは別として。主な理由は、EASTLがstlより読みやすいことです。対応物（私はこれが単にすべてのマクロと単純なコーディングスタイルの欠如のためであるとわかりました）。そこにはいくつかの気まぐれなことがあります（例外の#ifdefsのように）が、あなたを圧倒するものは何もありません。
他の人が述べたように、イテレータとコンテナに関するcplusplus.comの参照を見てください。
私はいくつかの異なるテキスト配列を反復処理できるという問題を解決しようとしていました。それらはすべて、大きなstructであるメモリ常駐型データベースに格納されています。
以下は、MFCテストアプリケーションでVisual Studio 2017 Community Editionを使用して作成されました。この投稿は私が遭遇したいくつかのうちの1つなので、例としてこれを含めています。
メモリ常駐データを含むstructは、次のようになりました。簡潔にするために要素の大部分を削除しました。また、使用されているプリプロセッサ定義も含まれていません（使用されているSDKはC++用およびC++用です）。
私がやってみたかったのは、ニーモニック用のテキスト文字列を含むさまざまなWCHAR二次元配列のイテレータを持つことです。
typedef struct tagUNINTRAM {
// stuff deleted ...
WCHAR ParaTransMnemo[MAX_TRANSM_NO][PARA_TRANSMNEMO_LEN]; /* prog #20 */
WCHAR ParaLeadThru[MAX_LEAD_NO][PARA_LEADTHRU_LEN]; /* prog #21 */
WCHAR ParaReportName[MAX_REPO_NO][PARA_REPORTNAME_LEN]; /* prog #22 */
WCHAR ParaSpeMnemo[MAX_SPEM_NO][PARA_SPEMNEMO_LEN]; /* prog #23 */
WCHAR ParaPCIF[MAX_PCIF_SIZE]; /* prog #39 */
WCHAR ParaAdjMnemo[MAX_ADJM_NO][PARA_ADJMNEMO_LEN]; /* prog #46 */
WCHAR ParaPrtModi[MAX_PRTMODI_NO][PARA_PRTMODI_LEN]; /* prog #47 */
WCHAR ParaMajorDEPT[MAX_MDEPT_NO][PARA_MAJORDEPT_LEN]; /* prog #48 */
// ... stuff deleted
} UNINIRAM;
現在の方法は、テンプレートを使用して各配列のプロキシクラスを定義してから、その配列を表すプロキシオブジェクトを使用して特定の配列を反復処理するための単一の反復子クラスを作成することです。
メモリ常駐データのコピーは、ディスクに対するメモリ常駐データの読み書きを処理するオブジェクトに格納されます。このクラスCFileParaには、テンプレートプロキシクラス（MnemonicIteratorDimSizeおよび派生元のサブクラスMnemonicIteratorDimSizeBase）とイテレータクラスMnemonicIteratorが含まれています。
作成されたプロキシオブジェクトは、すべてのプロキシクラスが派生する基本クラスによって記述されたインタフェースを介して必要な情報にアクセスするイテレータオブジェクトに添付されます。その結果、異なるプロキシクラスはすべて同じインタフェース、つまりプロキシ基本クラスのインタフェースを公開するため、複数の異なるプロキシクラスで使用できる単一タイプのイテレータクラスを持つことになります。
最初のことは、その種類のニーモニック用の特定のプロキシオブジェクトを生成するためにクラスファクトリに提供される識別子のセットを作成することでした。これらの識別子は、ユーザが見てそしておそらく変更することに関心がある特定のプロビジョニングデータを識別するためにユーザインターフェースの一部として使用される。
const static DWORD_PTR dwId_TransactionMnemonic = 1;
const static DWORD_PTR dwId_ReportMnemonic = 2;
const static DWORD_PTR dwId_SpecialMnemonic = 3;
const static DWORD_PTR dwId_LeadThroughMnemonic = 4;
プロキシクラス
テンプレートプロキシクラスとその基本クラスは次のとおりです。私はいくつかの異なる種類のwchar_tテキスト文字列配列に対応する必要がありました。ニーモニックの種類（目的）に応じて、2次元配列のニーモニックの数は異なり、ニーモニックの種類によって最大長は異なり、5文字から20文字の間で異なります。派生プロキシクラスのテンプレートは、各ニーモニックで最大文字数を必要とするテンプレートに自然に適合しました。プロキシオブジェクトが作成されたら、次にSetRange()メソッドを使用して実際のニーモニック配列とその範囲を指定します。
// proxy object which represents a particular subsection of the
// memory resident database each of which is an array of wchar_t
// text arrays though the number of array elements may vary.
class MnemonicIteratorDimSizeBase
{
DWORD_PTR m_Type;
public:
MnemonicIteratorDimSizeBase(DWORD_PTR x) { }
virtual ~MnemonicIteratorDimSizeBase() { }
virtual wchar_t *begin() = 0;
virtual wchar_t *end() = 0;
virtual wchar_t *get(int i) = 0;
virtual int ItemSize() = 0;
virtual int ItemCount() = 0;
virtual DWORD_PTR ItemType() { return m_Type; }
};
template <size_t sDimSize>
class MnemonicIteratorDimSize : public MnemonicIteratorDimSizeBase
{
wchar_t (*m_begin)[sDimSize];
wchar_t (*m_end)[sDimSize];
public:
MnemonicIteratorDimSize(DWORD_PTR x) : MnemonicIteratorDimSizeBase(x), m_begin(0), m_end(0) { }
virtual ~MnemonicIteratorDimSize() { }
virtual wchar_t *begin() { return m_begin[0]; }
virtual wchar_t *end() { return m_end[0]; }
virtual wchar_t *get(int i) { return m_begin[i]; }
virtual int ItemSize() { return sDimSize; }
virtual int ItemCount() { return m_end - m_begin; }
void SetRange(wchar_t (*begin)[sDimSize], wchar_t (*end)[sDimSize]) {
m_begin = begin; m_end = end;
}
};
イテレータクラス
イテレータクラス自体は次のとおりです。このクラスは、現時点で必要とされている基本的な順方向反復子機能のみを提供します。しかし、それ以外に何か追加のものが必要になったときに、これが変更されたり拡張されることを期待しています。
class MnemonicIterator
{
private:
MnemonicIteratorDimSizeBase *m_p; // we do not own this pointer. we just use it to access current item.
int m_index; // zero based index of item.
wchar_t *m_item; // value to be returned.
public:
MnemonicIterator(MnemonicIteratorDimSizeBase *p) : m_p(p) { }
~MnemonicIterator() { }
// a ranged for needs begin() and end() to determine the range.
// the range is up to but not including what end() returns.
MnemonicIterator & begin() { m_item = m_p->get(m_index = 0); return *this; } // begining of range of values for ranged for. first item
MnemonicIterator & end() { m_item = m_p->get(m_index = m_p->ItemCount()); return *this; } // end of range of values for ranged for. item after last item.
MnemonicIterator & operator ++ () { m_item = m_p->get(++m_index); return *this; } // prefix increment, ++p
MnemonicIterator & operator ++ (int i) { m_item = m_p->get(m_index++); return *this; } // postfix increment, p++
bool operator != (MnemonicIterator &p) { return **this != *p; } // minimum logical operator is not equal to
wchar_t * operator *() const { return m_item; } // dereference iterator to get what is pointed to
};
プロキシオブジェクトファクトリは、ニーモニック識別子に基づいて作成するオブジェクトを決定します。プロキシオブジェクトが作成され、返されるポインタは、どのニーモニックセクションのどれがアクセスされているかにかかわらず、統一されたインタフェースを持つように標準の基本クラス型です。 SetRange()メソッドは、プロキシが表す特定の配列要素とその配列要素の範囲をプロキシオブジェクトに指定するために使用されます。
CFilePara::MnemonicIteratorDimSizeBase * CFilePara::MakeIterator(DWORD_PTR x)
{
CFilePara::MnemonicIteratorDimSizeBase *mi = nullptr;
switch (x) {
case dwId_TransactionMnemonic:
{
CFilePara::MnemonicIteratorDimSize<PARA_TRANSMNEMO_LEN> *mk = new CFilePara::MnemonicIteratorDimSize<PARA_TRANSMNEMO_LEN>(x);
mk->SetRange(&m_Para.ParaTransMnemo[0], &m_Para.ParaTransMnemo[MAX_TRANSM_NO]);
mi = mk;
}
break;
case dwId_ReportMnemonic:
{
CFilePara::MnemonicIteratorDimSize<PARA_REPORTNAME_LEN> *mk = new CFilePara::MnemonicIteratorDimSize<PARA_REPORTNAME_LEN>(x);
mk->SetRange(&m_Para.ParaReportName[0], &m_Para.ParaReportName[MAX_REPO_NO]);
mi = mk;
}
break;
case dwId_SpecialMnemonic:
{
CFilePara::MnemonicIteratorDimSize<PARA_SPEMNEMO_LEN> *mk = new CFilePara::MnemonicIteratorDimSize<PARA_SPEMNEMO_LEN>(x);
mk->SetRange(&m_Para.ParaSpeMnemo[0], &m_Para.ParaSpeMnemo[MAX_SPEM_NO]);
mi = mk;
}
break;
case dwId_LeadThroughMnemonic:
{
CFilePara::MnemonicIteratorDimSize<PARA_LEADTHRU_LEN> *mk = new CFilePara::MnemonicIteratorDimSize<PARA_LEADTHRU_LEN>(x);
mk->SetRange(&m_Para.ParaLeadThru[0], &m_Para.ParaLeadThru[MAX_LEAD_NO]);
mi = mk;
}
break;
}
return mi;
}
プロキシクラスとイテレータを使用
次のループに示すように、プロキシクラスとそのイテレータを使用して、CListCtrlオブジェクトにニーモニックのリストを埋めます。私はstd::unique_ptrを使用していますので、プロキシクラスが不要になり、std::unique_ptrが範囲外になると、メモリはクリーンアップされます。
このソースコードが行うことは、指定されたニーモニック識別子に対応するstruct内に配列のプロキシオブジェクトを作成することです。その後、そのオブジェクトのイテレータを作成し、forコントロールを埋めるために範囲指定されたCListCtrlを使用してからクリーンアップします。これらはすべて生のwchar_tテキスト文字列であり、正確には配列要素の数である可能性があるため、テキストが確実にゼロで終了するように文字列を一時バッファにコピーします。
std::unique_ptr<CFilePara::MnemonicIteratorDimSizeBase> pObj(pFile->MakeIterator(m_IteratorType));
CFilePara::MnemonicIterator pIter(pObj.get()); // provide the raw pointer to the iterator who doesn't own it.
int i = 0; // CListCtrl index for zero based position to insert mnemonic.
for (auto x : pIter)
{
WCHAR szText[32] = { 0 }; // Temporary buffer.
wcsncpy_s(szText, 32, x, pObj->ItemSize());
m_mnemonicList.InsertItem(i, szText); i++;
}