C++ For Mathematicians (2006) [eng]

return b;

}

if (b<c) return c; return b;

}

At some point, we may want to apply max_of_three to another class. We could write more and more versions of this procedure, each with a different first line to accommodate the additional types.

The result is many different incarnations of the max_of_three procedure. This is legal in C++; one can have multiple procedures with the same name provided the types or number of arguments are different for each version. The procedure max_of_three(double,double,double) happily coexists with the version of max_of_three that acts on arguments of type PTriple. It is annoying that we need to create the exact same procedure over and over again for different types of arguments. Furthermore, if we want to change the algorithm for max_of_three, we need to edit all the different versions.

Fortunately, there is a better way. It is possible to write a single version of max_of_three that automatically adapts to the required situation using templates. Here is the template for the max_of_three procedure.

Program 12.1: The header file containing the template for the max of three procedure.

1 #ifndef MAX_OF_THREE_H

2#define MAX_OF_THREE_H

3

4template <class T>

5 T max_of_three(T a, T b, T c) {

6if (a<b) {

7 if (b<c) return c;

8return b;

9}

10if (b<c) return c;

11return b;

12}

13

14 #endif

There are two points to notice.

•The procedure is given, in full, in the header file, max_of_three.h. This is standard for templates. One does not separate the declaration in the header file from the code in the .cc file.

In addition, the keyword inline is not needed.

•The procedure begins with template <class T>. This sets up the letter T to stand for a type.

The remainder of the code is exactly what we had before with T standing for long, double, PTriple, or any other type. The letter T acts as a “type variable.”

The compiler is complaining that it cannot find an operator< that takes two arguments of type complex<double> at lines 6, 7, and 10 in the file max_of_three.h; this is precisely where the < expressions occur.

It is possible to create templates with multiple type parameters. Such templates look like this:

template <class A, class B>

void do_something(A arg1, B arg2) { ... }

When the compiler encounters code such as

long alpha = 4; double beta = 4.5;

do_something(alpha, beta);

it creates and uses a version of do_something in which A stands for long and B stands for double.

12.2Class templates

12.2.1 Using class templates

In Section 2.7 we showed how to declare C++ variables to hold complex numbers. After the directive #include <complex>, we have statements such as these:

complex<double> w(-3.4, 5.1); complex<long> z(4, -7);

The first declares a complex variable w in which the real and imaginary parts are double real numbers and the second declares z to be a Gaussian integer (long integer real and imaginary parts).

The class complex is, in fact, a class template. By specifying different types between the < and > delimiters, we create different classes. For example, we could use the Mod type (see Chapter 9):

12.2.2 Creating class templates

Now that we have examined how to use class templates we are led to the issue: How do we create class templates? The technique is similar to that of creating procedure templates. To demonstrate the process, we create our own, extremely limited version of the complex template that we call mycomplex. The template resides in a file named mycomplex.h; there is no mycomplex.cc file. Here is the header file containing the template.

Program 12.2: The template for the mycomplex classes.

1 #ifndef MY_COMPLEX_H

2#define MY_COMPLEX_H

3

4 #include <iostream>

5using namespace std;

6

7 template <class T>

8class mycomplex {

9

10private:

11T real_part;

12T imag_part;

13

14public:

15mycomplex<T>() {

16real_part = T(0);

17imag_part = T(0);

18}

19

20mycomplex<T>(T a) {

21real_part = a;

22imag_part = T(0);

23}

24

25mycomplex<T>(T a, T b) {

26real_part = a;

27imag_part = b;

28}

29

30T re() const { return real_part; }

31T im() const { return imag_part; }

32

33 };

34

35template<class T>

36ostream& operator<<(ostream& os, const mycomplex<T>& z) {

37os << "(" << z.re() << ") + (" << z.im() << ")i";

38return os;

39}

40

41 #endif

The overall structure of the class template is this:

template <class T> class mycomplex {

// private and public data and methods

};

Let’s examine this code.

•The initial template <class T> serves the same purpose as in the case of template procedures. This establishes T as a parameter specifying a type. When we declare a variable with a statement like this

There is, of course, a catch. We assign coef[0] with the value K(a). This is an explicit request to convert the value a to type K. This is fine if we are converting a long to a double or a double to a complex<double>, but fails when a is not convertible to type K, for example, if K were type double and a were type PTriple.

Notice the call to the private method deg_check(). This method scans the data held in coef to find the last nonzero value and resets dg accordingly. Various operations on polynomials might alter their degree (e.g., addition of polynomials, changing coefficients, etc.) and this method makes sure dg holds the correct value.

Next we have a three-argument constructor (lines 35–43). To create the polynomial ax2 + bx + c one simply invokes Polynomial<K>(a,b,c). As before, the three arguments need not be type K; it is enough that they be convertible to type K. For example, consider this code.

Polynomial< complex<double> > P(a,b,c);

This creates a polynomial P equal to 7x2 + (4 −3i)x + π.

Finally, it is useful to be able to create a polynomial given an array of coefficients. The constructor on lines 45–60 takes two arguments: the size of an array and an array of coefficients. The array is declared as type J*; that is, an array of elements of type J. The only requirement on J is that values of that type must be convertible to type K.

12.3.3 Get and set methods

We include an assortment of methods to inspect and modify the coefficients held in a Polynomial.

•The deg() method returns the degree of the polynomial. (See line 62.)

•The get(k) method returns the coefficient of xk. In the case where k is invalid (negative or greater than the degree), we return zero. (See lines 64–67.)

As an alternative to get(k) we provide operator[] (line 69). For a polynomial P, both P[k] and P.get(k) have the same effect. However, we have not set up operator[] to work on the left-hand side of an assignment; we cannot change the kth coefficient by a statement such as P[k]=c;.

•The isZero() method returns true if the polynomial is identically zero. See line 89.

•The set(idx,a) method sets the coefficient coef[idx] equal to the value a. See lines 71–76.

Some care must be taken here. First, if idx is negative, no action is taken. If idx is greater than the degree, we need to expand coef accordingly. Also, this method might set the highest coefficient to zero, so we invoke deg_check().

•The clear() method sets all coefficients to zero. See lines 78–82.

•The minimize() method frees up any wasted memory held in coef. It is conceivable that a polynomial may at one point have large degree (causing coef to expand) and then later have small degree. Although the size of coef grows and shrinks with the degree, the capacity of coef would remain large. This method causes the vector method reserve to be invoked for coef. See lines 84–87.

•Finally, we have the shift(n) method. See lines 91–105.

If n is positive, this has the effect of multiplying the polynomial by xn. Each coefficient is shifted upwards; the coefficient of xk before the shift becomes the coefficient of xk+n after.

Shifting with a negative index has the opposite effect. Coefficients are moved to lower powers of x. Coefficients shifted to negative positions are discarded.

Notice that we give the argument n a default value of 1 (see line 91). Thus

P.shift() is the same as P.shift(1).

12.3.4 Function methods

Polynomials are functions and to use them as such we provide a method named of. Invoking P.of(a) evaluates the polynomial p(x) at x = a. See lines 109–118.

An efficient way to evaluate a polynomial such as 3x4 +5x3 −6x2 +2x+7 at x = a is this:

In addition to the of method, we provide an operator() method (line 120). This way we can express function application in the natural way P(a) in addition to

P.of(a).

Because polynomials are functions, they may be composed and the result is again a polynomial. We use the same method names, of and operator(), for polynomial composition. For polynomials P and Q, the result of P.of(Q) (and also P(Q)) is the polynomial p(q(x)). See lines 122–135.

These methods depend on the ability to do polynomial arithmetic, and we describe those methods below (Subsection 12.3.6).