C ++標準ライブラリにtransform_ifがないのはなぜですか？
構成コピー（1. copy_ifで実行可能）から値のコンテナーへ、それらの値へのポインターのコンテナー（2. transformで実行可能）を実行する場合にユースケースが発生しました。
利用可能なツールでは、2ステップ未満で do it できません。
#include <vector>
#include <algorithm>
using namespace std;
struct ha {
int i;
explicit ha(int a) : i(a) {}
};
int main()
{
vector<ha> v{ ha{1}, ha{7}, ha{1} }; // initial vector
// GOAL : make a vector of pointers to elements with i < 2
vector<ha*> ph; // target vector
vector<ha*> pv; // temporary vector
// 1.
transform(v.begin(), v.end(), back_inserter(pv),
[](ha &arg) { return &arg; });
// 2.
copy_if(pv.begin(), pv.end(), back_inserter(ph),
[](ha *parg) { return parg->i < 2; }); // 2.
return 0;
}
もちろん、pvでremove_ifを呼び出して、一時的な必要性をなくすこともできますが、より良いことですが、 implement （単項演算の場合）は次のようになります。
template <
class InputIterator, class OutputIterator,
class UnaryOperator, class Pred
>
OutputIterator transform_if(InputIterator first1, InputIterator last1,
OutputIterator result, UnaryOperator op, Pred pred)
{
while (first1 != last1)
{
if (pred(*first1)) {
*result = op(*first1);
++result;
}
++first1;
}
return result;
}
// example call
transform_if(v.begin(), v.end(), back_inserter(ph),
[](ha &arg) { return &arg; }, // 1.
[](ha &arg) { return arg.i < 2; });// 2.
- 利用可能なC++標準ライブラリツールでよりエレガントな回避策がありますか？
- ライブラリに
transform_ifが存在しない理由はありますか？既存のツールの組み合わせは十分な回避策であるか、パフォーマンスに関して賢明であると考えられていますか？
標準ライブラリは基本アルゴリズムを支持しています。
可能であれば、コンテナとアルゴリズムは互いに独立している必要があります。
同様に、既存のアルゴリズムで構成できるアルゴリズムが短縮形として含まれることはほとんどありません。
変換ifが必要な場合は、簡単に記述できます。/today /で、オーバーヘッドが発生しない既製の作曲が必要な場合は、 Boost.Rangeなどのlazy rangeを持つ範囲ライブラリを使用できます 、例：
v | filtered(arg1 % 2) | transformed(arg1 * arg1 / 7.0)
@hvdがコメントで指摘しているように、transform_if doubleは異なるタイプ（この場合はdouble）になります。作曲順序は重要であり、ブースト範囲では次のように書くこともできます。
v | transformed(arg1 * arg1 / 7.0) | filtered(arg1 < 2.0)
セマンティクスが異なります。これにより、重要なポイントがわかります。
_
std::filter_and_transform、std::transform_and_filter、std::filter_transform_and_filterなどを含めることはほとんど意味がありませんなどを標準ライブラリに追加します。
サンプルを見るLive On Colir
#include <boost/range/algorithm.hpp>
#include <boost/range/adaptors.hpp>
using namespace boost::adaptors;
// only for succinct predicates without lambdas
#include <boost/phoenix.hpp>
using namespace boost::phoenix::arg_names;
// for demo
#include <iostream>
int main()
{
std::vector<int> const v { 1,2,3,4,5 };
boost::copy(
v | filtered(arg1 % 2) | transformed(arg1 * arg1 / 7.0),
std::ostream_iterator<double>(std::cout, "\n"));
}
新しいforループ表記法は多くの点で、コレクションのすべての要素にアクセスするアルゴリズムの必要性を減らします。ここでは、ループを記述してロジックを配置するだけでクリーンになりました。
std::vector< decltype( op( begin(coll) ) > output;
for( auto const& elem : coll )
{
if( pred( elem ) )
{
output.Push_back( op( elem ) );
}
}
アルゴリズムを導入することで、今では本当に多くの価値が提供されますか？はい、アルゴリズムはC++ 03に有用でしたが、実際には1つが必要でしたが、今は必要ないので、追加することには実質的な利点はありません。
実際の使用では、コードは常にそのように見えるとは限らないことに注意してください。関数「op」と「pred」は必ずしも必要ではなく、ラムダを作成してアルゴリズムに「適合する」必要があります。ロジックが複雑な場合の懸念を区別するのは良いことですが、入力型からメンバーを抽出してその値を確認するか、コレクションに追加するだけの場合は、アルゴリズムを使用するよりもはるかに簡単です。
さらに、何らかのtransform_ifを追加したら、変換の前または後に述語を適用するか、2つの述語を両方の場所に適用するかを決定する必要があります。
それで、私たちは何をするつもりですか？ 3つのアルゴリズムを追加しますか？ （また、コンパイラが変換の両端に述語を適用できる場合、ユーザーは誤って間違ったアルゴリズムを簡単に選択する可能性があり、コードはコンパイルされますが、間違った結果を生成します）。
また、コレクションが大きい場合、ユーザーはイテレーターまたはmap/reduceでループしたいですか？ map/reduceの導入により、方程式はさらに複雑になります。
基本的に、ライブラリはツールを提供します。ユーザーは、アルゴリズムでよくあるように逆ではなく、やりたいことに合わせてそれらを使用するためにここに残されます。 （上記のユーザーが蓄積したものを使用して、実際にやりたいことを調整する方法を参照してください）。
簡単な例として、地図。キーが偶数の場合、各要素に対して値を出力します。
std::vector< std::string > valuesOfEvenKeys
( std::map< int, std::string > const& keyValues )
{
std::vector< std::string > res;
for( auto const& elem: keyValues )
{
if( elem.first % 2 == 0 )
{
res.Push_back( elem.second );
}
}
return res;
}
素敵でシンプル。それをtransform_ifアルゴリズムにうまく当てはめますか？
この標準は、重複を最小限に抑えるように設計されています。
この特定のケースでは、単純なrange-forループにより、アルゴリズムの目的をより読みやすく簡潔な方法で実現できます。
// another way
vector<ha*> newVec;
for(auto& item : v) {
if (item.i < 2) {
newVec.Push_back(&item);
}
}
コンパイルし、診断を追加し、OPのアルゴリズムと鉱山の両方を並べて提示するように例を変更しました。
#include <vector>
#include <algorithm>
#include <iostream>
#include <iterator>
using namespace std;
struct ha {
explicit ha(int a) : i(a) {}
int i; // added this to solve compile error
};
// added diagnostic helpers
ostream& operator<<(ostream& os, const ha& t) {
os << "{ " << t.i << " }";
return os;
}
ostream& operator<<(ostream& os, const ha* t) {
os << "&" << *t;
return os;
}
int main()
{
vector<ha> v{ ha{1}, ha{7}, ha{1} }; // initial vector
// GOAL : make a vector of pointers to elements with i < 2
vector<ha*> ph; // target vector
vector<ha*> pv; // temporary vector
// 1.
transform(v.begin(), v.end(), back_inserter(pv),
[](ha &arg) { return &arg; });
// 2.
copy_if(pv.begin(), pv.end(), back_inserter(ph),
[](ha *parg) { return parg->i < 2; }); // 2.
// output diagnostics
copy(begin(v), end(v), ostream_iterator<ha>(cout));
cout << endl;
copy(begin(ph), end(ph), ostream_iterator<ha*>(cout));
cout << endl;
// another way
vector<ha*> newVec;
for(auto& item : v) {
if (item.i < 2) {
newVec.Push_back(&item);
}
}
// diagnostics
copy(begin(newVec), end(newVec), ostream_iterator<ha*>(cout));
cout << endl;
return 0;
}
久しぶりにこの質問を復活させてすみません。最近、同様の要件がありました。 boost :: optional：を取るback_insert_iteratorのバージョンを書くことで解決しました。
template<class Container>
struct optional_back_insert_iterator
: public std::iterator< std::output_iterator_tag,
void, void, void, void >
{
explicit optional_back_insert_iterator( Container& c )
: container(std::addressof(c))
{}
using value_type = typename Container::value_type;
optional_back_insert_iterator<Container>&
operator=( const boost::optional<value_type> opt )
{
if (opt) {
container->Push_back(std::move(opt.value()));
}
return *this;
}
optional_back_insert_iterator<Container>&
operator*() {
return *this;
}
optional_back_insert_iterator<Container>&
operator++() {
return *this;
}
optional_back_insert_iterator<Container>&
operator++(int) {
return *this;
}
protected:
Container* container;
};
template<class Container>
optional_back_insert_iterator<Container> optional_back_inserter(Container& container)
{
return optional_back_insert_iterator<Container>(container);
}
このように使用します：
transform(begin(s), end(s),
optional_back_inserter(d),
[](const auto& s) -> boost::optional<size_t> {
if (s.length() > 1)
return { s.length() * 2 };
else
return { boost::none };
});
しばらくして再びこの質問を見つけた後、 潜在的に有用な汎用イテレータアダプターを多数考案しました 元の質問にはstd::reference_wrapper。
ポインタの代わりにそれを使用すると、あなたは良いです：
#include <algorithm>
#include <functional> // std::reference_wrapper
#include <iostream>
#include <vector>
struct ha {
int i;
};
int main() {
std::vector<ha> v { {1}, {7}, {1}, };
std::vector<std::reference_wrapper<ha const> > ph; // target vector
copy_if(v.begin(), v.end(), back_inserter(ph), [](const ha &parg) { return parg.i < 2; });
for (ha const& el : ph)
std::cout << el.i << " ";
}
プリント
1 1
copy_ifを一緒に使用できます。 理由は何ですか？OutputItを定義します（ copy を参照）：
struct my_inserter: back_insert_iterator<vector<ha *>>
{
my_inserter(vector<ha *> &dst)
: back_insert_iterator<vector<ha *>>(back_inserter<vector<ha *>>(dst))
{
}
my_inserter &operator *()
{
return *this;
}
my_inserter &operator =(ha &arg)
{
*static_cast< back_insert_iterator<vector<ha *>> &>(*this) = &arg;
return *this;
}
};
コードを書き直します。
int main()
{
vector<ha> v{ ha{1}, ha{7}, ha{1} }; // initial vector
// GOAL : make a vector of pointers to elements with i < 2
vector<ha*> ph; // target vector
my_inserter yes(ph);
copy_if(v.begin(), v.end(), yes,
[](const ha &parg) { return parg.i < 2; });
return 0;
}
これは、質問1「利用可能なC++標準ライブラリツールを使用したよりエレガントな回避策はありますか？」に対する答えです。
C++ 17を使用できる場合は、C++標準ライブラリ機能のみを使用した簡単なソリューションにstd::optionalを使用できます。考え方は、マッピングがない場合にstd::nulloptを返すことです：
#include <iostream>
#include <optional>
#include <vector>
template <
class InputIterator, class OutputIterator,
class UnaryOperator
>
OutputIterator filter_transform(InputIterator first1, InputIterator last1,
OutputIterator result, UnaryOperator op)
{
while (first1 != last1)
{
if (auto mapped = op(*first1)) {
*result = std::move(mapped.value());
++result;
}
++first1;
}
return result;
}
struct ha {
int i;
explicit ha(int a) : i(a) {}
};
int main()
{
std::vector<ha> v{ ha{1}, ha{7}, ha{1} }; // initial vector
// GOAL : make a vector of pointers to elements with i < 2
std::vector<ha*> ph; // target vector
filter_transform(v.begin(), v.end(), back_inserter(ph),
[](ha &arg) { return arg.i < 2 ? std::make_optional(&arg) : std::nullopt; });
for (auto p : ph)
std::cout << p->i << std::endl;
return 0;
}
ここで、C++で Rustのアプローチ を実装したことに注意してください。
template <class InputIt, class OutputIt, class BinaryOp>
OutputIt
transform_if(InputIt it, InputIt end, OutputIt oit, BinaryOp op)
{
for(; it != end; ++it, (void) ++oit)
op(oit, *it);
return oit;
}
使用法：（CONDITIONとTRANSFORMはマクロではなく、適用する条件と変換のプレースホルダーであることに注意してください）
std::vector a{1, 2, 3, 4};
std::vector b;
return transform_if(a.begin(), a.end(), b.begin(),
[](auto oit, auto item) // Note the use of 'auto' to make life easier
{
if(CONDITION(item)) // Here's the 'if' part
*oit++ = TRANSFORM(item); // Here's the 'transform' part
}
);