我有一些类，由于各种原因超出了本讨论的范围，我无法修改（省略了不相关的实现细节）：
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 等的各种问题/答案之后，我想出了这个（目前半生不熟的）“解决方案”：
首先，自定义迭代器机制（注意：'function' 和 'bind' 的所有用法都来自 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 占位符等。他们真正关心的是：外部类型，内部类型，外部类型获取内部实例的方法，外部类型获取内部实例的方法。
有没有办法以某种方式“隐藏”模板类主体中的绑定？我一直无法找到一种方法来分别为类型和内部方法分别提供模板参数......
谢谢！
大卫