いくつかのクラスがありますが、この説明の範囲外のさまざまな理由で変更できません (無関係な実装の詳細は省略されています)。
class Foo { /* ... irrelevant public interface ... */ };
class Bar {
public:
Foo& get_foo(size_t index) { /* whatever */ }
size_t size_foo() { /* whatever */ }
};
(私が扱っている似たような 'Foo' および 'Bar' クラスはたくさんありますが、それはすべて他の場所から生成されたコードであり、サブクラス化したくないものなどです。)
[編集: 明確化 - 似たような 'Foo' および 'Bar' クラスは多数ありますが、各「外側」クラスには getter メソッドと size メソッドがあることが保証されています。getter メソッド名と戻り値の型のみが、「内部」に含まれる型が何であれ、「外部」ごとに異なります。
したがって、Quux インスタンスを含む Baz がある場合、Quux& Baz::get_quux(size_t index) と size_t Baz::size_quux() があります。]
Bar クラスの設計を考えると、STL アルゴリズム (for_each、find_if など) で簡単に使用することはできず、関数型アプローチを採用するのではなく、命令型ループを実行する必要があります (私が後者を好む理由は、この議論):
Bar b;
size_t numFoo = b.size_foo();
for (int fooIdx = 0; fooIdx < numFoo; ++fooIdx) {
Foo& f = b.get_foo(fooIdx);
/* ... do stuff with 'f' ... */
}
だから...私はカスタムイテレータを作成したことがなく、iterator_traitsなどに関するSOのさまざまな質問/回答を読んだ後、この(現在中途半端な)「解決策」を思いつきました:
まず、カスタム イテレータ メカニズム (注: 「関数」と「バインド」のすべての使用は、MSVC9 の std::tr1 からのものです):
// Iterator mechanism...
template <typename TOuter, typename TInner>
class ContainerIterator : public std::iterator<std::input_iterator_tag, TInner> {
public:
typedef function<TInner& (size_t)> func_type;
ContainerIterator(const ContainerIterator& other) : mFunc(other.mFunc), mIndex(other.mIndex) {}
ContainerIterator& operator++() { ++mIndex; return *this; }
bool operator==(const ContainerIterator& other) {
return ((mFunc.target<TOuter>() == other.mFunc.target<TOuter>()) && (mIndex == other.mIndex));
}
bool operator!=(const ContainerIterator& other) { return !(*this == other); }
TInner& operator*() { return mFunc(mIndex); }
private:
template<typename TOuter, typename TInner>
friend class ContainerProxy;
ContainerIterator(func_type func, size_t index = 0) : mFunc(func), mIndex(index) {}
function<TInner& (size_t)> mFunc;
size_t mIndex;
};
次に、内部コンテナーの開始と終了を表す有効なイテレーターを取得するメカニズム:
// Proxy(?) to the outer class instance, providing a way to get begin() and end()
// iterators to the inner contained instances...
template <typename TOuter, typename TInner>
class ContainerProxy {
public:
typedef function<TInner& (size_t)> access_func_type;
typedef function<size_t ()> size_func_type;
typedef ContainerIterator<TOuter, TInner> iter_type;
ContainerProxy(access_func_type accessFunc, size_func_type sizeFunc) : mAccessFunc(accessFunc), mSizeFunc(sizeFunc) {}
iter_type begin() const {
size_t numItems = mSizeFunc();
if (0 == numItems) return end();
else return ContainerIterator<TOuter, TInner>(mAccessFunc, 0);
}
iter_type end() const {
size_t numItems = mSizeFunc();
return ContainerIterator<TOuter, TInner>(mAccessFunc, numItems);
}
private:
access_func_type mAccessFunc;
size_func_type mSizeFunc;
};
これらのクラスは次のように使用できます。
// Sample function object for taking action on an LMX inner class instance yielded
// by iteration...
template <typename TInner>
class SomeTInnerFunctor {
public:
void operator()(const TInner& inner) {
/* ... whatever ... */
}
};
// Example of iterating over an outer class instance's inner container...
Bar b; /* assume populated which contained items ... */
ContainerProxy<Bar, Foo> bProxy(
bind(&Bar::get_foo, b, _1),
bind(&Bar::size_foo, b));
for_each(bProxy.begin(), bProxy.end(), SomeTInnerFunctor<Foo>());
経験的に、このソリューションは正しく機能します (簡潔にするために上記を編集するときに導入した可能性のあるコピー/貼り付けまたはタイプミスを除く)。
最後に、実際の質問:
呼び出し元が bind() や _1 プレースホルダーなどの使用を要求するのは好きではありません。彼らが本当に気にかけているのは、外側の型、内側の型、内側のインスタンスを取得する外側の型のメソッド、count 個の内側のインスタンスを取得する外側の型のメソッドです。
テンプレートクラスの本体でバインドを何らかの形で「隠す」方法はありますか? タイプと内部メソッドのテンプレート パラメーターを別々に提供する方法を見つけることができませんでした...
ありがとう！
デビッド