CS 311 Spring 2008
Assignment 3

Assignment 3 is due at 5 p.m. Thursday, February 21. It is worth 20 points.

Procedures

E-mail answers to the exercises below to ffggc@uaf.edu, using the subject “DA3”.

• Your answers should consist of two files: da3.h and da3.cpp, containing your code from Exercises A, B, C, and D. These files (or a single archive file containing them) should be attached to your e-mail message.
• Be sure to include your name in your e-mail.
• I may not read your homework e-mail immediately. If you wish to discuss the assignment (or anything else) with me, send me a separate message with a different subject line.

Exercises (20 pts total)

General

In each of the following four exercises, you are to write a function or function template. All four are to be in the files da3.h and da3.cpp. The templates should be implemented entirely in the header file. The non-templates should be prototyped in the header and implemented in the source, as usual.

Be sure to follow the coding standards. Standard 3A (“Requirements on template parameter types must be documented.”) and standard 3B (“Exceptions thrown by each function must be documented.”) now apply. You do not need to follow standard 3C.

In the files da3.h and da3.cpp, you may include any other functions or classes that you wish. These will not be tested; however, they must follow the coding standards. Also, generally, use of the C++ Standard Library is legal in this assignment; some exercises do have restrictions on how it may be used, however.

Test Program

I have written a single test program for all four exercises: da3_test.cpp. If you compile and run your package with this program (unmodified!), then it will test whether your package works properly.

Do not turn in da3_test.cpp.

Exercise A — Does It Throw?

Purpose

This exercise is all about calling code that may throw an exception, and catching the exception appropriately.

Instructions

Write a function template doesItThrow, prototyped as

template <typename Function>
bool doesItThrow(Function theFunc);

Function doesItThrow is given a pointer to a function, or something that acts like a function. It then calls this function with no parameters, catching any exceptions that result. Finally, it returns true if theFunc threw an exception, false otherwise.

Example usage:

void myFunc()
{ throw std::exception("Hi!"); }

bool result = doesItThrow(myFunc);

After the above call to doesItThrow, result should be true.

Other requirements:

• Make no assumptions about the type of the exception that might be thrown by the given function.
• Make no assumptions about the return value of theFunc; it may return a value, or it may not.
• Function doesItThrow should not throw.
• If the given function throws, then catch the exception and do not re-throw it.

Exercise B — Divide or Throw

Purpose

In this exercise you are to write code that may generate an error condition it cannot handle. Your code is to signal the client by throwing an exception. This exercise also requires you to deal with iterators that have few operations available.

Instructions

Write a function template divideAll, prototyped as

template <typename ForwardIterator, typename Number>
void divideAll(ForwardIterator first,
               ForwardIterator last,
               const Number & denom);

Function divideAll is given a range, specified as two iterators, in the usual way (as described in class), and a number (“denom”) to divide every item in the range by.

If the expression “(denom == 0)” is true, then divideAll should throw some appropriate exception and leave the range unchanged. Otherwise, it should divide every item in the range by denom, with the results being stored in the range.

Example usage:

double arr[3] = { 1.0, 3.0, 2.0 };
divideAll(arr, arr+3, 2.0);

The above should result in array arr holding values approximately equal to 0.5, 1.5, 1.0, in that order.

Other requirements:

• The type of your exception should be a derived class of std::exception.
• The what member function of your exception should return a nonempty string giving human-readable information about the error.
• You must correctly handle an empty range.
• The iterators you are given are forward iterators. This means you can do ++ on them, but not -- or the bracket operator, and you cannot add numbers to them.

Exercise C — Descending Sort

Purpose

This exercise requires you to deal with iterators and to do sorting, either by writing the code yourself, or by figuring out how to use the C++ STL to do a descending sort (hint: Google?).

Instructions

Write a function sortDescendingInt, prototyped as

template <typename RandomAccessIterator>
void sortDescendingInt(RandomAccessIterator first,
                       RandomAccessIterator last);

Function sortDescendingInt is given a range, which holds zero or more ints. The range is specified as two iterators, in the usual way (as described in class). It sorts the range in descending order, that is, by the operator “>”.

Example usage:

std::vector<int> v;
v.push_back(1);
v.push_back(5);
v.push_back(2);
v.push_back(0);
v.push_back(5);
sortDescendingInt(v.begin(), v.end());

The above should result in v holding the values 5, 5, 2, 1, 0, in that order.

Other requirements:

• You may write the sort yourself or call some C++ Standard Library function. If you do the latter, then you can do this with one function call (but it may take some doing to figure out how).
• You must correctly handle an empty range.
• The iterators you are given are random-access iterators. This means that, while they may not be pointers, you can do the usual pointer arithmetic operations on them. You can also pass them to functions that require random-access iterators (like std::sort; hint, hint).
• Your sorting algorithm does not need to be an especially fast one (we will talk about that later in the semester) But it should be able to handle a list of 100 ints in no more than a second on a reasonably new computer (a very lenient requirement indeed).

Exercise D — Print Reverse

Purpose

In this exercise, you are to implement a simple recursive algorithm.

Instructions

Write a recursive function (NOT a template) printRev, prototyped as

void printReverse(const std::string & printMe,
                  std::ostream & theStream);

Function printReverse is given a string and an ostream, or an object of a derived class. It prints the given string backwards, character by character, to the given stream.

Example usage:

printReverse("abc def", std::cout);

The above should print “fed cba” to cout.

Other requirements:

• Function printReverse must be recursive.
• You may assume that theStream can be used with operator<<, just like any ostream. Do not attempt to perform any other operations on theStream.
• You may not use Standard Template Library functions std::reverse or std::reverse_copy.
• You must correctly handle the empty string.
• Your function should not print a newline, unless it is present in the given string. Example:

  printReverse("abc", std::cout);
  cout << "x";

  The above should print “cbax” to cout.

• Be sure you correctly handle streams other than cout. Example:

  std::ostringstream oss;
  printReverse("abc", oss);

  After the above, oss.str() should be "cba".

CS 311 Spring 2008: Assignment 3 / Updated: 18 Feb 2008 / Glenn G. Chappell / ffggc@uaf.edu