CSCI 330: Lab 6 (spring 2024)

CSCI 330 Lab 6: using C++ templates to create variadic and higher order functions

This semester we saw the use of variadic functions (functions that can accept any number of parameter) and higher order functions in common lisp.

Our objective in this lab is to use templates to create one C++ function that is variadic, another that is higher order, and one that is both variadic and higher order.

Objectives

Templates can be used in C++ to create higher order functions (an example is available in file higher.cpp in the examples subdirectory of the lab6 repo), and can be used to create variadic functions (an example is available in file variadic.cpp in the examples subdirectory of the repo).

We'll apply these approaches to create three sets of function templates in our lab6.h:

apply: higher order (with one template for unary functions and a second template for binary functions)
sumDiffs: variadic, accepting one or more arguments (with one template for the single-argument case and another template for a recursive multiple-argument case)
chosenMin that is both higher order and variadic (and will require three function templates, two base cases and one general case)

In our lab6.cpp we'll include lab6.h, declare a variety of functions to serve as the higher order parameters to aaaa and cccc, and set up a main routine to demonstrate that our three sets of function templates work correctly.

Specifications and design suggestions

We have three different functions to support, each implemented through a set of templates in the lab6.h file.

apply takes either a unary function and a single argument to apply it to or a binary function and two arguments to apply it to, e.g.
```
   r = apply(pow, x, y); // runs pow on parameters x and y and returns the result
   r = apply(sqrt, x); // runs sqrt on parameter x and returns the result
```
The apply function assumes the data parameters and the function's return value are all the same type.
You'll need to create two templates for apply, one with two parameters (the function and the single data value) and one with three parameters (the function and the two data values). Both of these should be relatively easy to construct by following the higher.cpp example (in the examples subdirectory of the repo).
sumDiffs takes one or more parameters and treats them as pairs, computing the sum of the differences, e.g.
```
   r = sumDiff(w); // returns w
   r = sumDiff(w,x); // returns (w-x)
   r = sumDiff(w,x,y); // returns (w-x) + y
   r = sumDiff(w,x,y,z); // returns (w-x) + (y-z)
   r = sumDiff(a,b,c,d,e,f,g); // returns (a-b) + (c-d) + (e-f) + g
   etc
```
The sumDiffs function assumes all the arguments have the same type and that type is compatible with the - operation.
To implement this you'll need three template versions:
- one for the base case where there is just a single argument,
- one for the base case where there are just two arguments,
- one for the general recursive case that takes the front two arguments and a ... argument for the rest, computes the difference between the first two arguments, and adds that to the result of a recursive call.
This solution can be closely modeled on the variadic.cpp code in the examples subdirectory.
chosenMin takes as parameters one comparison function and two or more data values to apply it to. It then uses that comparison function to find the smallest out of all the values passed to it.
For example, suppose smaller(x,y) takes two integer parameters and returns the smaller. Then chosenMin(smaller, 5, 17, 32, 8, 93, 16) would use smaller to successively work through the values to find the smallest out of all of them.
As a design approach, I'd suggest having one version (the base case) that's much like your binary apply, and a second case that takes the function, the front two arguments, and a variadic argument for the rest (much like the general case of sumDiffs but with the function parameter thrown in the front). It could apply the function to the first two values to get the smaller of those, then make a recursive call passing the function, the result of the comparison it just did, and the variadic rest of the args.

Some examples of calls to the three functions and the corresponding output are shown in the testing section below.

Testing

To demonstrate that your functions work correctly, include some standard (non-templated) function definitions and a main routine in your lab6.cpp that demonstrates calls to each of functions aaaa, bbbb, and cccc with different combinations of function/value pairs.

A basic lab6.cpp is shown below, illustrating a set of valid calls using our templated functions. Feel free to create your own test cases, you aren't required to use these ones.

#include "lab6.h"
#include <cmath>
#include <iostream>
#include <string>
using namespace std;

string concat(string s1, string s2)
{
   return s1+s2;
}

int smallInt(int x, int y)
{
   if (x < y) return x;
   else return y;
}

string smallStr(string s1, string s2)
{
   if (s1 < s2) return s1;
   else return s2;
}

int main()
{
   // testing our variadic sumDiffs with different types and numbers of arguments
   int res1 = sumDiffs(5, 3, 8, 2, 1, -6);
   cout << "(5-3) + (8-2) + (1--6) should be 15, actually got: " << res1 << endl;
   double res2 = sumDiffs(1.0, 2.5, 3.6);
   cout << "(1-2.5) + 3.6 should be 2.1, actually got: " << res2 << endl;

   // testing our higher order apply with different function/parameter combos
   double res3 = apply(sqrt, 0.81);
   cout << "sqrt(0.81) should give 0.9, actually got: " << res3 << endl;
   string str1 = "foo";
   string str2 = "blah";
   string res4 = apply(concat, str1, str2);
   cout << "concat(foo, blah) should give fooblah, actually got: " << res4 << endl;

   // testing our variadic higher order function with different functions and numbers of args
   string res5 = chosenMin(smallStr, str1, str2);
   cout << "smaller of foo and blah should be blah, actually got: " << res5 << endl;
   int res6 = chosenMin(smallInt, 10, 5, 17, -3, 11);
   cout << "smaller of 10, 5, 17, -3, 11 should be -3, actually got: " << res6 << endl;
}

The output we would expect from running this would be something like

(5-3) + (8-2) + (1--6) should be 15, actually got: 15
(1-2.5) + 3.6 should be 2.1, actually got: 2.1
sqrt(0.81) should give 0.9, actually got: 0.9
concat(foo, blah) should give fooblah, actually got: fooblah
smaller of foo and blah should be blah, actually got: blah
smaller of 10, 5, 17, -3, 11 should be -3, actually got: -3