当多路调用多个子对象时,什么是阻止循环样板代码的优雅方法?
示例问题描述:
struct Foo {
void Boo();
void Hoo();
bool IsActivated();
};
struct FooAggregator {
...
void Boo();
void Hoo();
...
std::vector<Foo> m_foos;
};
FooAggregator::Boo() {
for(size_t i=0, e=m_foos.size(); i!=e; ++i) {
if(m_foos[i].IsActivated()) {
m_foos[i].Boo();
}
}
}
FooAggregator::Hoo() {
for(size_t i=0, e=m_foos.size(); i!=e; ++i) {
if(m_foos[i].IsActivated()) {
m_foos[i].Hoo();
}
}
}
正如您所看到的,FooAggregator实现了与单个Foo相同(相似)的接口,迭代调用其各自成员函数的所有Foo对象。
正如您所看到的,迭代循环是完整的样板,为FooAggregator的每个成员函数重复。
从FooAggregators成员函数的实现中删除样板的优雅方法是什么
答案 0 :(得分:6)
您可以使用Boost.Bind
作为@ Space_C0wb0y建议。但如果你出于某种原因不能使用它,那么你可以做这样的事情:
struct FooAggregator
{
typedef void (Foo::*Fun)();
void Boo() { CallForEach(m_foos.begin(), m_foos.end(), &Foo::Boo); }
void Hoo() { CallForEach(m_foos.begin(), m_foos.end(), &Foo::Hoo); }
template<typename FwdIterator>
void CallForEach(FwdIterator first, FwdIterator last, Fun fun)
{
while (first != last )
{
if(first->IsActivated())
{
(first->*fun)();
}
first++;
}
}
};
或者您可以使用std::for_each
中的<algorithm>
作为:
#include <algorithm>
struct FooAggregator
{
typedef void (Foo::*Fun)();
void Boo() { std::for_each(m_foos.begin(), m_foos.end(), Call(&Foo::Boo)); }
void Hoo() { std::for_each(m_foos.begin(), m_foos.end(), Call(&Foo::Hoo)); }
struct Call
{
Fun m_fun;
Call(Fun fun) : m_fun(fun) {}
void operator()(Foo & foo)
{
if(foo.IsActivated())
{
(foo.*m_fun)();
}
}
};
};
了解Function object以了解第二个示例。
在C ++ 0x(即C ++ 11)中,它非常简单。您可以在std::for_each
中使用lamda作为:
#include <algorithm>
struct FooAggregator
{
void Boo()
{
std::for_each(m_foos.begin(), m_foos.end(), [](Foo &foo){ if (foo.IsActivated()) foo.Boo(); } );
}
void Hoo()
{
std::for_each(m_foos.begin(), m_foos.end(), [](Foo &foo){ if (foo.IsActivated()) foo.Hoo(); } );
}
//other code
};
答案 1 :(得分:1)
您可以使用Boost.Bind将boost::function
对象传递到调度方法,该方法指定要调用的方法。那么你只需要一个可以用不同的目标方法作为参数调用的调度方法。
答案 2 :(得分:1)
我将采取Nawaz的第一个好例子,并简化一些:
(请记住,我想减少样板,不要引入最高级的功能。)
// FooAggregator.h
struct FooAggregator {
template<typename MemFn>
void CallForEachFoo(MemFn fun);
void Boo();
void Hoo();
};
// FooAggregator.cpp
template<typename MemFn>
void FooAggregator::CallForEachFoo(MemFn fun) {
BOOST_FOREACH(Foo& o, m_foos) {
if(o.IsActivated()) {
(o.*fun)();
}
}
}
void Boo() { CallForEachFoo(&Foo::Boo); }
void Hoo() { CallForEachFoo(&Foo::Hoo); }
答案 3 :(得分:0)
Nawaz的回答很有意思,但也有其他解决方案。
首先,您应该认识到您的聚合器非常Composite
模式。
其次,我会选择:
for_each
- 类似于传递函子的成员方法(实际上是2,因为const
重载)。对于外部迭代,请继续阅读:)
相对不幸的是,C ++迭代器语法并不真正适合“跳过”迭代器,但它仍然是可以实现的。
class ActiveIterator {
public:
friend class FooAggregator;
friend bool operator==(ActiveIterator lhs, ActiveIterator rhs) {
return lhs._it == rhs._it;
}
ActiveIterator& operator++() {
this->next();
return *this;
}
Foo* operator->() const { return _it::operator->(); }
Foo& operator*() const { return *_it; }
private:
typedef std::vector<Foo>::iterator base;
ActivateIterator(base begin, base end): _it(begin), _end(end) {
if (_it == _end || _it->IsActive()) { return; }
this->next();
}
void next() {
++it; while (_it != _end && !_it->IsActive()) { ++_it; }
}
base _it, _end;
};
然后,您的聚合只有Begin
和End
方法,并且由调用者与您的迭代器进行交互。
注意:你可以让模板一次性实现mutable / const实现
外部迭代仍然非常笨重,因为C ++缺少生成器语法来简化操作。