How to filter an array using partical function application

Question

I am working with a program that creates an array of data. The user should be able to use all entries or apply a filter. The filter function actually contains a lot of variables not directly related to the entries. The idea was to pass a function for filtering where parameters are already partially applied. I illustrate the general concept below with a (silly) example. Here, one can call get_matches() without a filter to get/print the whole array aka all numbers from 1 to 10, or pass a filter function to select eg only the even numbers.

foo.h

#include <functional>

typedef std::function<bool(const int)> SelectionFunction;

class Foo {

  public:
    // this works but I have to fake using pos
    void get_matches(SelectionFunction filter = [](const int pos) {(void)pos; return true;});

    // can one do something like this for readability?
    //SelectionFunction noFilter = [](const int pos) {(void)pos; return true;};
    //void get_matches(SelectionFunction filter = noFilter);
};

foo.cc

#include "foo.h"

#include <iostream>
#include <numeric>

using namespace std;

void
Foo::get_matches(SelectionFunction filter)
{
  // just to have some data for testing
  array<int, 10> a;
  iota(a.begin(), a.end(), 1);

  for (const auto& i : a)
    if (filter(i))
      cout << i << " ";
  cout << "\n";
}

and test.cc

#include "foo.h"

using namespace std;

bool some_func(int a, int b) {
  return a % b == 0;  // just some random stuff
}

int main() {
  Foo a;

  // default all numbers
  a.get_matches();

  // only even numbers
  auto filter = bind(some_func, placeholders::_1, 2);
  a.get_matches(filter);

  return 0;
}

This implementation works but does not really satisfy me. Esp. the "no filter" needs to have an unused argument to match the signature of the function which would raise an unused parameter error. Also it is not trivial to read imo. This can be improved by defining the default parameter explicitly as noFilter, but I could not get it compiled like that. Any suggestions how to do this better?

Answer 1

You could do something like this, to create a "view" on the selected items (without copying them). It shouldn't be too hard to make something similar for std::array too.

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

// the idea is to return a new vector 
// with references to the selected items in the input array
template<typename type_t>
auto create_selected_view(std::vector<type_t>& inputs, const std::vector<bool>& selections)
{
    // a plain vector of references is not allowed, but you can use std::reference_wrapper 
    std::vector<std::reference_wrapper<type_t>> selected_view;

    // only create a selection when sizes match
    if (inputs.size() == selections.size())
    {
        std::size_t n{0ul};
        for (auto& input : inputs)
        {
            if (selections[n])
            {
                // add a new reference to the output
                selected_view.emplace_back(input);
            }
            ++n;
        }
    }

    // return the view
    return selected_view;
}


int main()
{
    std::vector<int> input{ 1,2,3,4,5,6,7,8 };
    std::vector<bool> selections{ true,true,false,true,false,false,false,true };

    // the original vector must stay in scope for the selected view to be valid.
    auto selected_view = create_selected_view(input, selections);

    for(const auto value : selected_view )
    {
        std::cout << value << " ";
    }
}