copy_if with different types

Question

Is there a modern way of expressing the intent to conditionally copy from a source container of a different type to a destination container if I know how to extract the matching type?

It is easier to pose the question as a code-example:

#include <algorithm>
#include <vector>

struct Foo {};
struct FooBar{
    bool is_valid;
    Foo foo;
};

std::vector<Foo> get_valid_foos(const std::vector<FooBar>& foobars){
    std::vector<Foo> valid_foos;
    for(const auto& fbar : foobars){
        if(fbar.is_valid)
            valid_foos.push_back(fbar.foo);
    }
    return valid_foos;
}

std::vector<Foo> get_valid_foos_modern(const std::vector<FooBar>& foobars){
    std::vector<Foo> valid_foos;
    std::copy_if(foobars.begin(), foobars.end(), std::back_inserter(valid_foos),
        [](const auto& foobar){
            return foobar.is_valid;
        });
    //?? std::copy requires input and output types to match
    return valid_foos;
}

https://godbolt.org/g/miPbfW

Related: https://stackoverflow.com/q/23579832/1896169 . There is no `std::transform_if`, but if you are willing to use libraries, there are several libraries that can do this — Justin, Jun 18 '18 at 17:30
Of course, `std::copy_if` will work just fine if the source type can be assigned to the target type. — Pete Becker, Jun 18 '18 at 18:46
@PeteBecker: With the proviso that if the assignment gives a warning, you'll get a template instantiation stack in your warning message. VS2017 produces about 50 lines for an int-to-float conversion. The "extraction function" could be as simple as `static_cast( )`. — MSalters, Jun 21 '18 at 15:41
@MSalters -- yes, some compilers are horrible to work with. Especially when they decide that they know your requirements better than you do. Turn off stupid warnings! — Pete Becker, Jun 21 '18 at 16:52

score 13 · Accepted Answer · answered Jun 18 '18 at 17:31

13

Using range-v3:

std::vector<Foo> get_valid_foos(const std::vector<FooBar>& foobars) {
    return foobars
        | view::filter(&FooBar::is_valid)
        | view::transform(&FooBar::foo);
}

That's pretty expressive.

answered Jun 18 '18 at 17:31

Barry

286,269
29
621
977

This is beautiful, why isn't this in the standard? – arynaq Jun 18 '18 at 17:31
1

@arynaq There's work on adding something like this. See the [Ranges TS](https://en.cppreference.com/w/cpp/experimental/ranges) – Justin Jun 18 '18 at 17:32
Ah unfortunately no MSVC support from what I can see on the docs. – arynaq Jun 18 '18 at 17:33
1

@arynaq If you use [vcpkg](https://github.com/Microsoft/vcpkg), there's support for a limited version of Range V3 – Justin Jun 18 '18 at 17:34
3

@arynaq It's likely that a lot of the Ranges TS will be in C++20. – Barry Jun 18 '18 at 17:34
Which is rather late TBH. The "View Template Library" by Martin Weiser and Gary Powell was presented at the First Workshop on C++ Template Metaprogramming, back in Oct 2000. – MSalters Jun 21 '18 at 15:50
Hm. While you are at it, why not pass it in as a `std::span`, which should also be in C++20? – Deduplicator Sep 17 '18 at 18:32
@Deduplicator range-v3 at least compiles in C++14 :-) – Barry Sep 17 '18 at 18:59
Is there any part of the guideline-support-library (which also contains `span`) not available for C++11 up? – Deduplicator Sep 17 '18 at 20:36

Xirema · Answer 2 · 2018-06-18T17:59:06.317

Like the other answer put forth, Ranges offer a very concise solution to this problem. We're still a few years out from C++20 being standardized though (and another few years before it becomes accessible in enterprise environments) so we need a C++17-compatible solution.

What you're looking for is a hypothetical transform_if, which was not included in the Standard Library for various reasons

You have a couple of options.

The simplest is to just combine std::copy_if and std::transform:

std::vector<Foo> get_valid_foos_modern(const std::vector<FooBar>& foobars){
    std::vector<FooBar> valid_foobars;
    std::copy_if(foobars.begin(), foobars.end(), std::back_inserter(valid_foobars), [](const auto& foobar){
        return foobar.is_valid;
    });
    std::vector<Foo> valid_foos;
    std::transform(valid_foobars.begin(), valid_foobars.end(), std::back_inserter(valid_foos), [](auto const& fooBar) {return fooBar.foo;});
    return valid_foos;
}

The downside to this approach is that it creates temporary FooBar objects for each object that is going to get transformed, which you may find undesirable. You could roll your own transform_if algorithm implementation:

template<typename InputIterator, typename OutputIterator, typename Predicate, typename TransformFunc>
OutputIterator transform_if(
    InputIterator&& begin, 
    InputIterator&& end, 
    OutputIterator&& out, 
    Predicate&& predicate, 
    TransformFunc&& transformer
) {
    for(; begin != end; ++begin, ++out) {
        if(predicate(*begin))
            *out = transformer(*begin);
    }
    return out;
}

Which you'd then be able to use directly in your code:

std::vector<Foo> get_valid_foos_modern(const std::vector<FooBar>& foobars){
    std::vector<Foo> valid_foos;
    transform_if(
        foobars.begin(), 
        foobars.end(), 
        std::back_inserter(valid_foos), 
        [](const auto& foobar) { return foobar.is_valid;},
        [](auto const& foobar) { return foobar.foo;}
    );
    return valid_foos;
}

Justin · Answer 3 · 2018-09-17T18:15:38.403

Although not as nice as range-v3, you could use Boost Range:

std::vector<Foo> get_valid_foos(const std::vector<FooBar>& foobars) {
    std::vector<Foo> result;

    boost::push_back(
        result, foobars | boost::adaptors::filtered([](const FooBar& foobar) {
                    return foobar.is_valid;
                }) | boost::adaptors::transformed([](const FooBar& foobar) {
                    return foobar.foo;
                }));

    return result;
}

Demo

YSC · Answer 4 · 2018-06-19T14:30:54.380

A back insertor iterator it will try and push_back anything that is assigned to it. Currently, you get an error because it = foobar is ill-formed. Indeed vector_of_foo.push_back(foobar) is ill-formed itself.

If only there was a way to implicitly convert a FooBar into a Foo... wait! There is! Well, the annoying thing is that it introduces a circular dependency between Foo and FooBar. Let us break it with CRTP!

template<class TFoo>
struct TFooBar
{
    bool is_valid;
    TFoo foo;
};
struct Foo
{
    Foo() = default;
    Foo(TFooBar<Foo> const& src) { *this = src.foo; }
};
using FooBar = TFooBar<Foo>;

Now, std::back_inserter(foos) = FooBar{} does what is expected. And copy_if will behave too!

auto get_valid_foos_modern(const std::vector<FooBar>& foobars){
    std::vector<Foo> result;
    std::copy_if(begin(foobars), end(foobars), std::back_inserter(result),
        [](const auto& foobar) {
            return foobar.is_valid;
    });
    return result;
}

Demo: http://coliru.stacked-crooked.com/a/a40aeca7a9a057b2

score 0 · Answer 5 · answered Jun 18 '18 at 17:39

0

This calls for a hypothetical ~~std::transform_if~~, which is not available (why?).

A somewhat expensive work-around would be to std::copy_if into a temporary vector, followed by a std::transform:

std::vector<FooBar> foobars_with_valid_foos;
std::copy_if(
    foobars.begin()
,   foobars.end()
,   std::back_inserter(foobars_with_valid_foos)
,   [](const auto& foobar){
        return foobar.is_valid;
    }
);
std::vector<Foo> valid_foos;
std::transform(
    foobars_with_valid_foos.begin()
,   foobars_with_valid_foos.end()
,   std::back_inserter(valid_foos)
,   [](const auto& foobar){
        return foobar.foo;
    }
);
return valid_foos;

Demo.

answered Jun 18 '18 at 17:39

Sergey Kalinichenko

714,442
84
1,110
1,523

I have never seen this formatting style before.... I've never seen `,`s at the beginning of a line in a function call. – Justin Jun 18 '18 at 17:50
2

@Justin This style is [borrowed from SQL](https://hackernoon.com/winning-arguments-with-data-leading-with-commas-in-sql-672b3b81eac9). – Sergey Kalinichenko Jun 18 '18 at 17:55
temporary solution is slower – Andrei R. Jun 20 '18 at 07:39
@AndreiR. Slower than what? Two of the other four solutions on the page use a temporary. – Sergey Kalinichenko Jun 20 '18 at 09:02
@dasblinkenlight, ranges solution(filter + transform) doesn't use a temporary, and neither does trivial solution from OP's question – Andrei R. Jun 20 '18 at 09:12
@AndreiR. That's what I call "premature optimization". – Sergey Kalinichenko Jun 20 '18 at 09:32
@dasblinkenlight, I believe simpler code working faster is called "elegant solution", rather than "premature optimization" – Andrei R. Jun 20 '18 at 17:53
@AndreiR. Any talk about speed without profiling is premature optimization. Besides, elegance of two easy-to-read self-explanatory function calls is pretty tough to beat. – Sergey Kalinichenko Jun 20 '18 at 18:00

score 0 · Answer 6 · answered Nov 18 '20 at 17:36

#include <iterator>
#include <functional>
#include <vector>
#include <iostream>

template<typename Container,
         typename In>
class MappedInsertIterator
    : public std::back_insert_iterator<Container>
{
protected:
    using Out = typename Container::value_type;
    using Transformer = std::function<Out(const In&)>;

public:
    MappedInsertIterator() = delete;

    template<typename F>
        requires std::is_invocable_r_v<Out, F, In>
    explicit MappedInsertIterator(Container& c, F&& fn);

    virtual ~MappedInsertIterator() = default;

public:
    auto operator*() -> MappedInsertIterator&;
    auto operator=(const auto& value) -> MappedInsertIterator&;

protected:
    Transformer m_fn;
};

template<typename Container, typename In>
template<typename F>
    requires std::is_invocable_r_v<typename Container::value_type, F, In>
inline MappedInsertIterator<Container, In>::MappedInsertIterator(Container& c, F&& fn)
    : std::back_insert_iterator<Container>(c)
    , m_fn(std::forward<F>(fn))
{}

template<typename Container, typename In>
inline auto MappedInsertIterator<Container, In>::operator*() -> MappedInsertIterator&
{ return *this; }

template<typename Container, typename In>
auto MappedInsertIterator<Container, In>::operator=(const auto& value) -> MappedInsertIterator&
{
    std::back_insert_iterator<Container>::operator=(m_fn(value));
    return *this;
}


int main()
{
    struct Telemetry { float voltage; unsigned timestamp; };

    std::vector<Telemetry> items =
        {
            Telemetry { .voltage = 200, .timestamp = 101 }, // accepted
            Telemetry { .voltage = 250, .timestamp = 102 }, // accepted
            Telemetry { .voltage = 300, .timestamp = 203 }, // rejected
        };

    static auto predicate = [](const Telemetry& t){ return t.timestamp < 200; };
    static auto transform = [](const Telemetry& t){ return t.voltage; };

    std::vector<float> voltages;
    using iterator_t = MappedInsertIterator<decltype(voltages), Telemetry>;
    std::copy_if(items.cbegin(), items.cend(), iterator_t(voltages, transform), predicate);

    for (const auto& v : voltages)
        std::cout << v << std::endl;
}

copy_if with different types

6 Answers6

Linked