我正在编写一些代码,并且有一个部分用于执行一次性排序功能。为了实现它,我决定最简单的方法是重载 operator< 函数。我更愿意做的是通过使用某种 boost::bind、boost::phoenix、lambda 或其他类型的实现,使排序的实现更接近实际调用。不幸的是,我无法访问新的 C++11 功能。下面是一些示例代码。
// In a header
struct foo
{
char * a;
char * c_str() { return a; }
}
// In a header
struct bar
{
foo * X;
bar(foo * _X) : X(_X) {}
bool operator < (const bar& rhs) const
{
return std::string(X->c_str()) < std::string(rhs.X->c_str());
}
};
struct bars : public std::vector<bar> { ... some stuff };
// Some other header
bars Bs;
// A cpp file
... other stuff happens that fills the Xs vector with objects
...::Function()
{
// Current use and it works fine
std::sort(Bs.begin(), Bs.end())
// Would like something that accomplishes this:
// std::sort(Bs.begin(), Bs.end(),
// std::string(lhs.X->c_str()) < std::string(rhs.X->c_str()))
// A non-working example of what I'm trying to do
// std::sort(Xs.begin(), Xs.end(),
// std::string((bind(bar::X->c_str(), _1)) <
// std::string((bind(bar::X->c_str(), _2)) )
}
当我试图找出如何访问成员指针、成员函数然后将结果全部转换到 boost::bind 函数中时,我迷路了。
感谢您的帮助。
最佳答案
我相信你可以通过充分的帮助摆脱困境
- boost Phoenix
bind
和lambda
- boost 绑定(bind)
保护
但是,我学会了避免这些情况。 编辑 事实上,请参阅下面的此类装置。我发现这非常容易出错且难以推理。
您所看到的实质上违反了 Law Of Demeter .如果您“只是”编写代码(而不是在 lambda 中),那么它已经处理了太多任务。
所以我要做的第一件事就是重新考虑类设计。
我要做的第二件事是从你的比较者那里/提取/不同的职责。注意,比较器做了三件事:
- 访问lhs中X的c_str()
- 访问rhs中X的c_str()
- 比较两者
前两个步骤显然是提取的候选者。让我们首先编写保留的通用比较器:
template <typename F>
struct compare_by_impl {
compare_by_impl(F f = F{}) : _f(std::move(f)) {}
template <typename T, typename U>
bool operator()(T const& a, U const& b) const {
return _f(a) < _f(b);
}
private:
F _f;
};
一如既往,拥有可以推导出访问器类型的工厂函数是件好事(如果你可以在那里使用 Phoenix 就可以逃脱,它将节省你指定表达式模板中涉及的(神秘的)类型名称):
template <typename Accessor>
compare_by_impl<Accessor> comparer_by(Accessor&& f) {
return compare_by_impl<Accessor>(std::forward<Accessor>(f));
}
现在您已经可以通过排序调用移动实现:
void Function()
{
struct accessX_c_str {
std::string operator()(bar const& b) const {
return b.X->c_str();
}
};
std::sort(Bs.begin(), Bs.end(), comparer_by(accessX_c_str()));
}
我个人会把它留在那里。
这里有一些更扭曲的装置:
// to avoid `comparer_by`
std::sort(Bs.begin(), Bs.end(), phx::bind(accessX_c_str(), arg1) < phx::bind(accessX_c_str(), arg2));
// to avoid any helper types (!?!?!? untested!)
std::sort(Bs.begin(), Bs.end(),
phx::construct<std::string>(phx::bind(&foo::c_str, phx::lambda [ phx::bind(&bar::X, arg1) ](arg1)))
< phx::construct<std::string>(phx::bind(&foo::c_str, phx::lambda [ phx::bind(&bar::X, arg1) ](arg2)))
);
关于c++ - 如何为涉及对象成员、间接和强制转换的排序算法实现 lambda 函数?,我们在Stack Overflow上找到一个类似的问题: https://stackoverflow.com/questions/21861265/