CSCI 330: Lab 6 (spring 2025)

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), and discussion can be found on the lecture resources page at the end of the week for Mar 31-A4.

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

applyboth: higher order, accepting two unary functions and one data value
printAll: variadic, accepting one or more data arguments (with one template for the single-argument case and another template for a recursive multiple-argument case)
chain that is both higher order and variadic, accepting one data value and one or more functions (and will require function templates for the base and general cases)

In our lab6.cpp we'll include lab6.h, declare a variety of functions to serve as the higher order parameters to applyboth and chain, 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.

applyboth takes two unary functions (say f1 and f2) and a single data value (say d) and returns the result of f1(f2(d)), e.g.
```
   r = applyboth(floor, sqrt, x); // returns result of floor(sqrt(x))
```
The applyboth function assumes the data parameter and the functions' return values are all the same type.
You'll need to create a template for applyboth with three parameters (the two functions and the data value). This should be relatively easy to construct by following the higher.cpp example (in the examples subdirectory of the repo).
printAll takes one or more parameters and for each value prints a tab then the value, and prints a newline after the last one, e.g.
```
   r = printAll(a, b, c, d);
would have the same effect as
   cout << '\t' << a;
   cout << '\t' << b;
   cout << '\t' << c;
   cout << '\t' << d;
   cout << endl;
```
This solution can be closely modeled on the variadic.cpp code in the examples subdirectory.
chain has the form chain(data, f1, f2, ..., fn) where n >= 1. I.e. it expects one data value followed by one or more functions where each function expects exactly one parameter and returns a value, and all the data types are the same (i.e. all the return types and all the expected parameter types are of the same type as the initial data value).
The behaviour of chain is to compute f1(data) and use it's result as the parameter for f2, then the result of that as the parameter for f3, etc etc, eventually returning the result from fn. Thus chain(5.6, f, g, h) would compute and return the result of h(g(f(5.6))).

Testing

Testing of printAll is relatively straightforward: simply have your main routine include a variety of calls with differing numbers of parameters and types.

To test applyboth and chain, however, you'll need a few sets of unary functions that expect and return values of the same type. You can use existing C++ library functions for this or write your own or a combination of both. (E.g. log/sqrt/ceil for doubles, toupper/tolower for chars, etc.)