Lecture 11: Functions as objects (function pointers), a.k.a. functional programming

Suppose, we are extending our awesome math library from the error handling lecture and decided to add functions for computing squares. This is the code we have now:

struct SqrtError {};

// Compute square root using Newton's method, the implementation does not matter
// (that's the point of this lecture!).
double Sqrt(double a) {
  if (a < 0) {
    throw SqrtError{};
  }
  if (a == 0) {
    return 0;
  }
  double x = 1;
  double b = a;
  // pick a good estimate, this is not the fastest way to do it
  if (a > 1) {
    while (b > 1) {
      b /= 4;
      x *= 2;
    }
  } else if (a < 1) {
    while (b < 1) {
      b *= 4;
      x /= 2;
    }
  }
  for (int i = 0; i < 7; ++i) {
    x = (x + (a / x) ) / 2;
  }
  return x;
}

// other math functions
double Abs(double x) {
  if (x == 0) return +0.0;
  if (x < 0) return -x;
  return x;
}

double Square(double x) {
  return x * x;
}

int Round(double x) {
  return (int)x;
}

Let's also add a couple of helpers to make our lives easier:

template<class It>
void Print(It begin, It end) {
  for (; begin != end; ++begin) {
    cout << *begin << '\t';
  }
  cout << '\n';
}

template<class Vector>
void PrintCollection(const string & name, Vector v) {
  cout << name << ":\t";
  Print(v.begin(), v.end());
}

Now, here is a program that uses the functions above:

// the goal of this program is to apply each function to some inputs
int main(int argc, char * argv[]) {
  vector<double> v{-2.718, -1, 0, 1, 2, 3, 4, 3.14};
  // create a second vector without negatives for square root
  vector<double> v2{0, 1, 2, 3, 4, 3.14, 36, 64, 1e32};

  vector<double> squares;
  for (double x : v) {
    squares.push_back(Square(x));
  }
  vector<double> absolutes;
  for (double x : v) {
    absolutes.push_back(Abs(x));
  }
  vector<int> converted_to_ints;
  for (double x : v) {
    converted_to_int.push_back(Round(x));
  }
  vector<double> square_roots;
  for (double x : v2) { // note that this uses v2
    square_roots.push_back(Sqrt(x));
  }

  // print the output
  PrintCollection("squares", squares);
  PrintCollection("vector 1", v);
  PrintCollection("absolutes", absolutes);
  PrintCollection("converted ints", converted_to_ints);
  PrintCollection("vector 2", v2);
  PrintCollection("square roots", square_roots);


  return 0;
}

The code above has a bunch of repeated loops. How can we merge them so the code is easier to manage? If all of them were over v, we could perhaps merge the loop bodies, but the last loop is over v2. The simplest way to abstract repeated code that is parametric over some values is to create a function. For example, if we had a bunch of expressions like x * x - x and y * y - y, we could create a function int f(int a) { return a * a - a; } to abstract over them. So, what are the parameters that change between the loops? The input vector and the function we apply. So, we need a function wrapping the following code snippet:

vector<double> output;
for (double x : INPUT) {
  output.push_back(FUNCTION_TO_APPLY(x));
}
return output;

We can generalize our Map function to work on arbitrary inputs and outputs using templates:

// In is the parameter type of the function we are expecting, Out is the return type
template<class In, class Out>
vector<Out> Map(const vector<In> & input,
                (Out(*)(In)) function_to_apply) {
  vector<Out> output;
  for (double x : input) {
    output.push_back(function_to_apply(x));
  }
  return output;
}

The code above is good enough for us. While at it, we may want to enable some conversions for the function types (for example, if our function returns a short and a short can be automatically converted to an int, we may want to apply it to generate an int as well). The standard library (but not the language!) ships with a type to represent functions that has these conveniences built-in: std::function. Let's rewrite Map using it:

#include <functional>

template<class In, class Out>
vector<Out> Map(const vector<In> & input,
                function<Out(In)> function_to_apply) {
  vector<Out> output;
  for (double x : input) {
    output.push_back(function_to_apply(x));
  }
  return output;
}

Now, we can rewrite our main function to have no loops:

vector<double> squares = Map<double, double>(v, Square);
vector<double> absolutes = Map<double, double>(v, Abs);
vector<int> converted_to_ints = Map<double, int>(v, Round);
vector<double> square_roots = Map<double, double>(v2, Sqrt);

We need to give Map the template parameters because the compiler cannot infer those in this case. Now that we have our Map function all well-rounded, we can also improve its implementation: we can allocate the space for the output all at once to reduce the number of allocations.

#include <functional>

template<class In, class Out>
vector<Out> Map(const vector<In> & input,
                function<Out(In)> function_to_apply) {
  vector<Out> output;
  output.reserve(input.size()); // the line we just added to do only 1 allocation
  for (double x : input) {
    output.push_back(function_to_apply(x));
  }
  return output;
}

Note: all functions here are parts of the <algorithm> library or <numeric> library. So, you need to include those headers.

Map is a very generic function, and it would be useful whenever we need to apply an unknown transformation over a bunch of things. The standard library of course has its version of it called std::transform with some differences:

• it uses iterators so it works on any type of collection (linked lists, vectors, sets, …) that have an iterator interface.
• it uses some type introspection to not need the template arguments to be specified most of the time.
• rather than creating its own output, it requires a pre-allocated output iterator (so, we create the vector first, then call std::transform).

Without further ado, here is how we would compute converted_to_ints using std::transform (compare it to how we called Map earlier):

// pre-allocate the space by creating a vector of the same size as the input
vector<int> converted_to_ints(v.size()); 
std::transform(v.begin(), // beginning of input
               v.end(), // end of input
               converted_to_ints.begin(), // beginning of output
               Round); // function to apply

Also note that transform is pretty versatile. We could choose to pass around only a small range of the input by giving it the appropriate iterators. Now, let's look into other higher-order functions we can use: