• A Common Need:
  • Passing a function pointer to a method/function
• Examples:
  • Passing a comparator (i.e., a method of comparing values) to a sorting method/function
  • Passing a filter to an output method/function
• A Less-Common Need (Satisfied by Lambda Expressions):
  • Passing an anonymous (i.e., un-named) function

• Syntax of the Expression:
  • [] () mutable throw() -> type
• Explanation:
  • [] is the capture clause (a.k.a., lambda introducer) that contains the variables to access from the surrounding scope
  • () is the optional parameter list (a.k.a, lambda declarator)
  • mutable is the optional modifier that allows the lambda to modify captured values
  • throw() is the exception specification
  • type is the return type
• Syntax of the Capture Clause:
  • [identifier] capture identifier by value (where multiple identifiers are delimited by a comma)
  • [&identifier] capture identifier by reference (where multiple identifiers are delimited by a comma)
  • [=] capture all external variables by value
  • [&] capture all external variables by reference

• The Callable Type:
  • A type for which the INVOKE operation is applicable
• A Convenient Wrapper:
  • std::function in <functional>

• Definition of std::function:
  • template < class R, class... Args >
    class function<R(Args...)>;
• Explanation:
  • R denotes the type of the result
  • Args denotes the arguments

• The Setting:
  • We want to find the closest destination to a particular origin
• The Need for a Lambda Expression:
  • There are many different ways to calculate the distance

The closest() Function

cppexamples/lambdas/VectorMathExample.cpp (Fragment: closest)

/**
 * A function that finds the distance between an origin
 * and the closest destination.
 *
 * @param origin        The origin
 * @param destinations  The destinations
 * @param m             The number of destinations
 * @pram metric         The metric to use
 * @return              The distance to the closest destination
 */
double closest(double origin[2], double destinations[][2], int m,
               std::function<double (double[], double[])> metric) {
  
  double  min = INFINITY;

  for (int i=0; i<m; i++) {
    double temp = metric(origin, destinations[i]);
    if (temp < min) {
      min = temp;
    }
  }
  return min;
}
        

Note: This function is passed the origin, the destinations, the number of destinations, and the std::function to use to calculate the distance.

One Invocation of closest()

cppexamples/lambdas/VectorMathExample.cpp (Fragment: Euclidean)

  distance = closest(origin, destinations, 3,
                     // A Lambda expression for the Euclidean distance
                     [](double p[2], double q[2]) -> double {
                       double sum = 0.0;
                       for (int i=0; i<2; i++) {
                         sum += (p[i] - q[i])*(p[i] - q[i]);
                       }
                       return sqrt(sum);
                     });
        

Another Invocation of closest()

cppexamples/lambdas/VectorMathExample.cpp (Fragment: rectilinear)

  double distance;
  distance = closest(origin, destinations, 3,
                     // A Lambda expression for the rectilinear distance
                     [](double p[2], double q[2]) -> double {
                       double sum = 0.0;
                       for (int i=0; i<2; i++) {
                         sum += abs(p[i] - q[i]);
                       }
                       return sum;
                     });
        

• The Setting:
  • A unit testing framework/harness
• The Need for a Lambda Expression:
  • Pass a block of code that should throw an exception

The assertThrows() Function

/**
 * Check to see if a lambda expression throws a particular exception.
 *
 * @tparam T       The class of the exception
 * @param  lambda  The lambda expression to execute
 * @throws         invalid_argument if the exception is not thrown
 */
template<class T>
void assertThrows(std::function<void ()> lambda) {
  bool doesThrow = false;
  
  try {
    lambda();
  } catch(const exception& e) {
    doesThrow = dynamic_cast<const T*>(&e) != nullptr;
  }
  
  if (!doesThrow) {
    throw(invalid_argument("Expected " + string(typeid(T).name()) + " to be thrown"));
  }
}

The Unit Test

    try {
      assertThrows<out_of_range>([](void) {
      
        Sequence seq = {3,4,6};
          
        seq.get(-1);
      });
    } catch (const invalid_argument& ia) { 
      printf("Failed test: %s\n", ia.what());
    }