Homework 10 -- Exception Handling and Function Templates

1.

One way to think about what an exception means is to imagine that the function throwing the exception returns immediately, without returning a value. This is referred to as a failed function call.

🔗

When a function call fails, program execution returns to the location in the program’s code that called the failed function. It is this location that can actually HANDLE the exception thrown by the failed function call.

🔗

To indicate programmaticallywhere a failed function should return to for exception handling, use _________________ .

🔗

a try/catch block
an exception specification list
stack unwinding
a custom exception class

🔗

2.

True, or false: When an exception occurs during program execution, there is considerable overhead in the run-time environment.

🔗

true
false

🔗

3.

🔗

4.

There may be multiple kinds of exceptions, each from a different exception class. This allows you to write multiple catch blocks, each handling a different kind of failure.

🔗

Which of the following is the CORRECT way to create a "catch all" block to handle any type of unhandled exception?

🔗

catch ( ... ) { // exception handling code here }
catch ( ) { // exception handling code here }
catch ( all ) { // exception handling code here }
catch ( * ) { // exception handling code here }

🔗

5.

🔗

6.

Which of the following is FALSE?

🔗

In the real word, error handling plays only a minor role in the time it takes to develop large software projects.
Exceptions are a "clean" way of reporting errors encountered during program execution.
You should only use exceptions for error situations, not for normal control flow of your program.
When an exception is thrown by a function, the execution of that function is halted.

🔗

7.

Suppose that while your program is executing, an exception is thrown for which your code does not provide a handler. What happens?

🔗

The program execution ends in a "crash", caused by a system call to terminate().
The compiler-supplied "default handler" kicks in to handle the situation gracefully.
The program continues running, picking up from the line of code following the failed function call.

🔗

8.

True, or false: Function failableFunction has the ability to throw an exception. If function myFun calls failableFunction, then myFun is REQUIRED by the compiler to handle any resulting exceptions; failure to provide a handler for each possible thrown exception will result in a compile-time error.

🔗

false
true

🔗

9.

According to techterms.com,

🔗

...in the world of software development, "deprecated" refers to functions or elements that are in the process of being replaced by newer ones. The term comes from the verb "to deprecate," which means to disapprove of something. While deprecated items may work in the current version of a programming language, they may not function in future updates. Therefore, software developers are advised to replace deprecated items with other options.
🔗

🔗

Which of the following is deprecated in C++11?

🔗

exception specifications, such as including "throw(FileNotFoundException)" as part of a function protoype.
try/catch blocks
exception handling
the standard library exception class

🔗

10.

🔗

11.

We have defined a function, mystery(int a, int b), that takes two integers, `a` and `b`, and returns a mysterious string result. Sometimes the function may fail and throw an exception.

🔗

Write a second function, myFun(int a, int b), that does the following:

🔗

- Call mystery(a, b).

🔗

- If the call results in a normal return, return that result.

🔗

- If the call results in a domain_error exception, return the exception’s "what" message.

🔗

- If the call results in any other kind of exception, return the string "FAILURE".

🔗

Use a try-catch block to help you solve this problem.

🔗

For example:

🔗

Test	Result
cout << myFun(0, 1); 🔗	2 🔗
cout << myFun(4, 5); 🔗	I don't like those numbers 🔗
cout << myFun(5, 5); 🔗	FAILURE 🔗

#include <sstream>

#include <iostream>
#include <fstream>
#include <sstream>
#include <string>
#include <cmath>
#include <vector>
#include <algorithm>
#include <stdexcept>

using namespace std;
#define SEPARATOR "#<ab@17943918#@>#"

// mystery
// returns a mysterious result, or throws an exception
string mystery(int a, int b)
{
    stringstream ss;
	if (a == 4) { throw domain_error("I don't like those numbers"); }
	if (b == 9) { throw domain_error("Those numbers are annoying me"); }
	if (a == b) { throw invalid_argument("Wow, those are awful!"); }
	if (a == -b) { throw invalid_argument("Not cool, man!"); }
	ss << (a * 15 + b * 2) % 11;
	return ss.str();
}

^^^^
string myFun(int a, int b)
{

}
====
#define DOCTEST_CONFIG_IMPLEMENT_WITH_MAIN
#include "doctest.h"

TEST_CASE( "test1" ) {
    std::stringstream cout;
    cout << myFun(0, 1);

;
    std::string answer = "2";
    CHECK( cout.str() == answer );
}

TEST_CASE( "test2" ) {
    std::stringstream cout;
    cout << myFun(4, 5);

;
    std::string answer = "I don't like those numbers";
    CHECK( cout.str() == answer );
}

TEST_CASE( "test3" ) {
    std::stringstream cout;
    cout << myFun(5, 5);

;
    std::string answer = "FAILURE";
    CHECK( cout.str() == answer );
}

TEST_CASE( "test4" ) {
    std::stringstream cout;
    cout << myFun(1, 2);

;
    std::string answer = "8";
    CHECK( cout.str() == answer );
}

TEST_CASE( "test5" ) {
    std::stringstream cout;
    cout << myFun(10, 9);

;
    std::string answer = "Those numbers are annoying me";
    CHECK( cout.str() == answer );
}

TEST_CASE( "test6" ) {
    std::stringstream cout;
    cout << myFun(-3, 3);

;
    std::string answer = "FAILURE";
    CHECK( cout.str() == answer );
}

TEST_CASE( "test7" ) {
    std::stringstream cout;
    cout << myFun(7, -7);

;
    std::string answer = "FAILURE";
    CHECK( cout.str() == answer );
}

TEST_CASE( "test8" ) {
    std::stringstream cout;
    cout << myFun(4, 0);

;
    std::string answer = "I don't like those numbers";
    CHECK( cout.str() == answer );
}

TEST_CASE( "test9" ) {
    std::stringstream cout;
    cout << myFun(11, 0);

;
    std::string answer = "0";
    CHECK( cout.str() == answer );
}

TEST_CASE( "test10" ) {
    std::stringstream cout;
    string val = myFun(-25, 25);
    if (val == "FAILURE") cout << "OK";
    else cout << "NOT OK";

;
    std::string answer = "OK";
    CHECK( cout.str() == answer );
}

TEST_CASE( "test11" ) {
    std::stringstream cout;
    string val = myFun(4, 4);
    if (val == "I don't like those numbers") cout << "YEP";
    else cout << "NOPE";

;
    std::string answer = "YEP";
    CHECK( cout.str() == answer );
}

TEST_CASE( "test12" ) {
    std::stringstream cout;
    string val = myFun(25, 125);
    if (val == "FAILURE") cout << "oops";
    else cout << val;

;
    std::string answer = "9";
    CHECK( cout.str() == answer );
}

🔗

12.

Write a function array_sum that takes two arguments: an integer array called ’nums’ and an integer called ’size’ representing the number of values stored in the array. The function accumulates the sum of the values in the ’nums’ array and returns that sum.

🔗

If size < 1, the function throws a domain_error exception with the message, "size < 1 is not allowed".

🔗

For example:

🔗

Test	Result
int arr[1] = {3}; int sum; try { sum = array_sum(arr, 1); cout << sum; } catch(...) { cout << "Your code threw an exception." << endl; } 🔗	3 🔗
int arr[5] = {1, 2, 3, 4, 5}; int sum; try { sum = array_sum(arr, -4); cout << sum; } catch(domain_error e) { cout << e.what() << endl; } catch(...) { cout << "wrong exception type" << endl; } 🔗	size < 1 is not allowed 🔗
int arr[5] = {1, 2, 3, 4, 5}; int sum; try { sum = array_sum(arr, 5); cout << sum; } catch(domain_error e) { cout << e.what() << endl; } catch(...) { cout << "wrong exception type" << endl; } 🔗	15 🔗

Test

Result

int arr[1] = {3};
int sum;
try {
    sum = array_sum(arr, 1);
    cout << sum;
}
catch(...) {
    cout << "Your code threw an exception." << endl;
}

🔗

int arr[5] = {1, 2, 3, 4, 5};
int sum;
try {
    sum = array_sum(arr, -4);
    cout << sum;
}
catch(domain_error e) {
    cout << e.what() << endl;
}
catch(...) {
    cout << "wrong exception type" << endl;
}

🔗

size < 1 is not allowed

🔗

int arr[5] = {1, 2, 3, 4, 5};
int sum;
try {
    sum = array_sum(arr, 5);
    cout << sum;
}
catch(domain_error e) {
    cout << e.what() << endl;
}
catch(...) {
    cout << "wrong exception type" << endl;
}

🔗

#include <sstream>

^^^^
// Precondition: size >= 1
// Postcondition: Adds the first size-many elements of `nums` and returns
// the result.
// Exception: Throws a domain_error if the precondition is violated.
int array_sum(int nums[], int size)
{

}
====
#define DOCTEST_CONFIG_IMPLEMENT_WITH_MAIN
#include "doctest.h"

TEST_CASE( "test1" ) {
    std::stringstream cout;
    int arr[1] = {3};
    int sum;
    try {
       sum = array_sum(arr, 1);
       cout << sum;
    }
    catch(...)
    {
       cout << "Your code threw an exception.";
    }

;
    std::string answer = "3";
    CHECK( cout.str() == answer );
}

TEST_CASE( "test2" ) {
    std::stringstream cout;
    int arr[5] = {1, 2, 3, 4, 5};
    int sum;
    try {
       sum = array_sum(arr, -4);
       cout << sum;
    }
    catch(const std::domain_error& e)
    {
       cout << e.what();
    }
    catch(...)
    {
       cout << "wrong exception type";
    }

;
    std::string answer = "size < 1 is not allowed";
    CHECK( cout.str() == answer );
}

TEST_CASE( "test3" ) {
    std::stringstream cout;
    int arr[5] = {1, 2, 3, 4, 5};
    int sum;
    try {
       sum = array_sum(arr, 5);
       cout << sum;
    }
    catch(const std::domain_error& e)
    {
       cout << e.what();
    }
    catch(...)
    {
       cout << "wrong exception type";
    }

;
    std::string answer = "15";
    CHECK( cout.str() == answer );
}

TEST_CASE( "test4" ) {
    std::stringstream cout;
    int arr[5] = {1, 10, 100, 1000, -3};
    int sum;
    try {
       sum = array_sum(arr, 0);
       cout << sum;
    }
    catch(const std::domain_error& e)
    {
       cout << e.what();
    }
    catch(...)
    {
       cout << "wrong exception type";
    }

;
    std::string answer = "size < 1 is not allowed";
    CHECK( cout.str() == answer );
}

TEST_CASE( "test5" ) {
    std::stringstream cout;
    int arr[5] = {1, 10, 100, 1000, -3};
    int sum;
    try {
       sum = array_sum(arr, 3);
       cout << sum;
    }
    catch(const std::domain_error& e)
    {
       cout << e.what();
    }
    catch(...)
    {
       cout << "wrong exception type";
    }

;
    std::string answer = "111";
    CHECK( cout.str() == answer );
}

TEST_CASE( "test6" ) {
    std::stringstream cout;
    int arr[5] = {0, 1, 3, -5, 8};
    int sum;
    try {
       sum = array_sum(arr, -1);
       cout << sum;
    }
    catch(const std::domain_error& e)
    {
       cout << e.what();
    }
    catch(...)
    {
       cout << "wrong exception type";
    }

;
    std::string answer = "size < 1 is not allowed";
    CHECK( cout.str() == answer );
}

TEST_CASE( "test7" ) {
    std::stringstream cout;
    int arr[6] = {-10, 0, 1, 3, -5, 8};
    int sum;
    try {
       sum = array_sum(arr, -2);
       cout << sum;
    }
    catch(const std::domain_error& e)
    {
       cout << "correct";
    }
    catch(...)
    {
       cout << "wrong exception type";
    }

;
    std::string answer = "correct";
    CHECK( cout.str() == answer );
}

TEST_CASE( "test8" ) {
    std::stringstream cout;
    int arr[6] = {-10, 0, 1, 3, -5, 8};
    int sum;
    try {
       sum = array_sum(arr, 3);
       if (sum == -9) cout << "okey dokey";
    }
    catch(...)
    {
       cout << "Houston, we have a problem.";
    }

;
    std::string answer = "okey dokey";
    CHECK( cout.str() == answer );
}

🔗

13.

Write a function template compare that takes two values of the same type and prints the message "Those are the same" if the items are equal; if they are unequal, the function prints the message "Those are different".

🔗

This template should work for any type that can use the "==" operator and the copy constructor.

🔗

NOTE: The compare template has a void return type.

🔗

For example:

🔗

Test	Result
compare(3, 7); 🔗	Those are different 🔗
compare("blueberry", "blueberry"); 🔗	Those are the same 🔗

#include <sstream>

#include <iostream>
#include <fstream>
#include <iostream>
#include <sstream>
#include <string>
#include <cmath>
#include <vector>
#include <algorithm>
#include "Pixel.h"
#include "Person.h"

class Pixel
{
   public:
    // CONSTRUTOR
    Pixel( int r=0, int g=0, int b=0 )
    { rval = r; gval = g; bval = b; }

// MODIFICATION MEMBER FUNCTIONS
    void set( int r, int g, int b )
    { rval = r; gval = g; bval = b; }

void setRed( int r )
    { rval = r; }

void setGreen( int g )
    { gval = g; }

void setBlue( int b )
    { bval = b; }

// ACCESSOR MEMBER FUNCTIONS
    int getRed( ) const
    { return rval; }

int getGreen( ) const
    { return gval; }

int getBlue( ) const
    { return bval; }

// FRIEND FUNCTIONS
    friend std::ostream& operator<< (std::ostream& out, const Pixel& pix);
    friend std::istream& operator>> (std::istream& in, Pixel& pix);

private:
    // INSTANCE VARIABLES
    int rval;   // red level for RGB color model, 0 <= rval <=255
    int gval;   // green level for RGB color model, 0 <= rval <=255
    int bval;   // blue level for RGB color model, 0 <= rval <=255

}; // end Pixel class definition

/* operator==
 * Equivalence operator for pixels.
 */
bool operator== (const Pixel& pix1, const Pixel& pix2)
{
   return (pix1.getRed() == pix2.getRed()) &&
          (pix1.getGreen() == pix2.getGreen()) &&
          (pix1.getBlue() == pix2.getBlue());
}

bool operator> (const Pixel& pix1, const Pixel& pix2)
{
    int sum1 = pix1.getRed() + pix1.getGreen() + pix1.getBlue();
    int sum2 = pix2.getRed() + pix2.getGreen() + pix2.getBlue();
    return (sum1 > sum2);
}

bool operator< (const Pixel& pix1, const Pixel& pix2)
{
    int sum1 = pix1.getRed() + pix1.getGreen() + pix1.getBlue();
    int sum2 = pix2.getRed() + pix2.getGreen() + pix2.getBlue();
    return (sum1 < sum2);
}

/* operator!=
 * Inequivalence operator for pixels.
 */
bool operator!= (const Pixel& pix1, const Pixel& pix2)
{
   return !(pix1 == pix2);
}

/* operator<<
 * Stream output operator (<<) for outputting the contents of a pixel.
 * Example: A pixel with red value 100, green value 150, and blue value 200
 *    will produce the following output:100 150 200
 * Note: Returns the `out` parameter to allow chaining of stream output.
 */
std::ostream& operator<< (std::ostream& out, const Pixel& pix)
{
   out << pix.getRed() << " " << pix.getGreen() << " " << pix.getBlue();

return out;
}

/* operator>>
 * Stream input operator (>> for reading a pixel from an input stream.
 * Precondition: `in` holds a string of three integers separated by spaces;
 *    each integer must be in the range 0 to 255, inclusive.
 * Postconditions:
 *    -The red value of pix is set to the first integer.
 *    -The blue value of pix is set to the third integer.
 * Note: Returns the `in` parameter to allow chaining of stream input.
 */
std::istream& operator>> (std::istream& in, Pixel& pix)
{
   int r, g, b;
   in >> r >> g >> b;
   pix.setRed(r);
   pix.setGreen(g);
   pix.setBlue(b);

return in;
}

std::stringstream cout;
^^^^

====
#define DOCTEST_CONFIG_IMPLEMENT_WITH_MAIN
#include "doctest.h"

TEST_CASE( "test1" ) {
    cout = std::stringstream();
    compare(3, 7);
    std::string answer = "Those are different";
    CHECK( cout.str() == answer );
}

TEST_CASE( "test2" ) {
    cout = std::stringstream();
    compare("blueberry", "blueberry");

std::string answer = "Those are the same";
    CHECK( cout.str() == answer );
}

TEST_CASE( "test3" ) {
    cout = std::stringstream();
    double u = 3.14; double v = 1.0101;
    compare(u, v);

std::string answer = "Those are different";
    CHECK( cout.str() == answer );
}

TEST_CASE( "test4" ) {
    cout = std::stringstream();
    Pixel pix1(0, 1, 2); Pixel pix2(0, 1, 2);
    compare(pix1, pix2);

std::string answer = "Those are the same";
    CHECK( cout.str() == answer );
}

TEST_CASE( "test5" ) {
    cout = std::stringstream();
    Pixel pix1(0, 1, 2); Pixel pix2(2, 1, 0);
    compare(pix1, pix2);

std::string answer = "Those are different";
    CHECK( cout.str() == answer );
}

🔗

14.

Write a function template swapper that takes two values passed by reference and swaps them.

🔗

NOTE: The swapper template has a void return type.

🔗

For example:

🔗

Test	Result
int x = 3; int y = 7; swapper(x, y); cout < "x = " < x < " and y = " < y < endl; 🔗	x = 7 and y = 3 🔗
string a = "raspberry"; string b = "preserves"; swapper(a, b); cout < "a = " < a < " and b = " < b < endl; 🔗	a = preserves and b = raspberry 🔗

Test

Result

int x = 3;
int y = 7;
swapper(x, y);
cout < "x = " < x < " and y = " < y < endl;

🔗

x = 7 and y = 3

🔗

string a = "raspberry";
string b = "preserves";
swapper(a, b);
cout < "a = " < a < " and b = " < b < endl;

🔗

a = preserves and b = raspberry

🔗

#include <sstream>

#include <iostream>
#include <fstream>
#include <iostream>
#include <sstream>
#include <string>
#include <cmath>
#include <vector>
#include <algorithm>
#include "Pixel.h"

class Pixel
{
   public:
    // CONSTRUTOR
    Pixel( int r=0, int g=0, int b=0 )
    { rval = r; gval = g; bval = b; }

// MODIFICATION MEMBER FUNCTIONS
    void set( int r, int g, int b )
    { rval = r; gval = g; bval = b; }

void setRed( int r )
    { rval = r; }

void setGreen( int g )
    { gval = g; }

void setBlue( int b )
    { bval = b; }

// ACCESSOR MEMBER FUNCTIONS
    int getRed( ) const
    { return rval; }

int getGreen( ) const
    { return gval; }

int getBlue( ) const
    { return bval; }

// FRIEND FUNCTIONS
    friend std::ostream& operator<< (std::ostream& out, const Pixel& pix);
    friend std::istream& operator>> (std::istream& in, Pixel& pix);

private:
    // INSTANCE VARIABLES
    int rval;   // red level for RGB color model, 0 <= rval <=255
    int gval;   // green level for RGB color model, 0 <= rval <=255
    int bval;   // blue level for RGB color model, 0 <= rval <=255

}; // end Pixel class definition

/* operator==
 * Equivalence operator for pixels.
 */
bool operator== (const Pixel& pix1, const Pixel& pix2)
{
   return (pix1.getRed() == pix2.getRed()) &&
          (pix1.getGreen() == pix2.getGreen()) &&
          (pix1.getBlue() == pix2.getBlue());
}

/* operator!=
 * Inequivalence operator for pixels.
 */
bool operator!= (const Pixel& pix1, const Pixel& pix2)
{
   return !(pix1 == pix2);
}

/* operator<<
 * Stream output operator (<<) for outputting the contents of a pixel.
 * Example: A pixel with red value 100, green value 150, and blue value 200
 *    will produce the following output:100 150 200
 * Note: Returns the `out` parameter to allow chaining of stream output.
 */
std::ostream& operator<< (std::ostream& out, const Pixel& pix)
{
   out << pix.getRed() << " " << pix.getGreen() << " " << pix.getBlue();

return out;
}

/* operator>>
 * Stream input operator (>> for reading a pixel from an input stream.
 * Precondition: `in` holds a string of three integers separated by spaces;
 *    each integer must be in the range 0 to 255, inclusive.
 * Postconditions:
 *    -The red value of pix is set to the first integer.
 *    -The blue value of pix is set to the third integer.
 * Note: Returns the `in` parameter to allow chaining of stream input.
 */
std::istream& operator>> (std::istream& in, Pixel& pix)
{
   int r, g, b;
   in >> r >> g >> b;
   pix.setRed(r);
   pix.setGreen(g);
   pix.setBlue(b);

return in;
}

^^^^

====
#define DOCTEST_CONFIG_IMPLEMENT_WITH_MAIN
#include "doctest.h"

TEST_CASE( "test1" ) {
    std::stringstream cout;
    int x = 3; int y = 7;
    swapper(x, y);
    cout << "x = " << x << " and y = " << y;

std::string answer = "x = 7 and y = 3";
    CHECK( cout.str() == answer );
}

TEST_CASE( "test2" ) {
    std::stringstream cout;
    std::string a = "raspberry"; std::string b = "preserves";
    swapper(a, b);
    cout << "a = " << a << " and b = " << b;

std::string answer = "a = preserves and b = raspberry";
    CHECK( cout.str() == answer );
}

TEST_CASE( "test3" ) {
    std::stringstream cout;
    double u = 3.14; double v = 1.0101;
    swapper(u, v);
    cout << "u = " << u << " and v = " << v;

std::string answer = "u = 1.0101 and v = 3.14";
    CHECK( cout.str() == answer );
}

TEST_CASE( "test4" ) {
    std::stringstream cout;
    Pixel pix1(0, 1, 2); Pixel pix2(10, 9, 5);
    swapper(pix1, pix2);
    cout << "pix1 = " << pix1 << " and pix2 = " << pix2;

std::string answer = "pix1 = 10 9 5 and pix2 = 0 1 2";
    CHECK( cout.str() == answer );
}

🔗

15.

Write a function template maximum that takes two values of the same type and returns the larger value. This template should work for any type that can use the ">" operator and the copy constructor.

🔗

For example:

🔗

Test	Result
int x = 3; int y = 7; cout << "The maximum is " << maximum(x, y) << endl; 🔗	The maximum is 7 🔗
string a = "raspberry"; string b = "jelly"; cout << "The maximum is " << maximum(a, b) << endl; 🔗	The maximum is 7 🔗

#include <sstream>

#include <iostream>
#include <fstream>
#include <iostream>
#include <sstream>
#include <string>
#include <cmath>
#include <vector>
#include <algorithm>
#include "Pixel.h"

class Pixel
{
   public:
    // CONSTRUTOR
    Pixel( int r=0, int g=0, int b=0 )
    { rval = r; gval = g; bval = b; }

// MODIFICATION MEMBER FUNCTIONS
    void set( int r, int g, int b )
    { rval = r; gval = g; bval = b; }

void setRed( int r )
    { rval = r; }

void setGreen( int g )
    { gval = g; }

void setBlue( int b )
    { bval = b; }

// ACCESSOR MEMBER FUNCTIONS
    int getRed( ) const
    { return rval; }

int getGreen( ) const
    { return gval; }

int getBlue( ) const
    { return bval; }

// FRIEND FUNCTIONS
    friend std::ostream& operator<< (std::ostream& out, const Pixel& pix);
    friend std::istream& operator>> (std::istream& in, Pixel& pix);

private:
    // INSTANCE VARIABLES
    int rval;   // red level for RGB color model, 0 <= rval <=255
    int gval;   // green level for RGB color model, 0 <= rval <=255
    int bval;   // blue level for RGB color model, 0 <= rval <=255

}; // end Pixel class definition

/* operator==
 * Equivalence operator for pixels.
 */
bool operator== (const Pixel& pix1, const Pixel& pix2)
{
   return (pix1.getRed() == pix2.getRed()) &&
          (pix1.getGreen() == pix2.getGreen()) &&
          (pix1.getBlue() == pix2.getBlue());
}

bool operator> (const Pixel& pix1, const Pixel& pix2)
{
    int sum1 = pix1.getRed() + pix1.getGreen() + pix1.getBlue();
    int sum2 = pix2.getRed() + pix2.getGreen() + pix2.getBlue();
    return (sum1 > sum2);
}

bool operator< (const Pixel& pix1, const Pixel& pix2)
{
    int sum1 = pix1.getRed() + pix1.getGreen() + pix1.getBlue();
    int sum2 = pix2.getRed() + pix2.getGreen() + pix2.getBlue();
    return (sum1 < sum2);
}

/* operator!=
 * Inequivalence operator for pixels.
 */
bool operator!= (const Pixel& pix1, const Pixel& pix2)
{
   return !(pix1 == pix2);
}

/* operator<<
 * Stream output operator (<<) for outputting the contents of a pixel.
 * Example: A pixel with red value 100, green value 150, and blue value 200
 *    will produce the following output:100 150 200
 * Note: Returns the `out` parameter to allow chaining of stream output.
 */
std::ostream& operator<< (std::ostream& out, const Pixel& pix)
{
   out << pix.getRed() << " " << pix.getGreen() << " " << pix.getBlue();

return out;
}

/* operator>>
 * Stream input operator (>> for reading a pixel from an input stream.
 * Precondition: `in` holds a string of three integers separated by spaces;
 *    each integer must be in the range 0 to 255, inclusive.
 * Postconditions:
 *    -The red value of pix is set to the first integer.
 *    -The blue value of pix is set to the third integer.
 * Note: Returns the `in` parameter to allow chaining of stream input.
 */
std::istream& operator>> (std::istream& in, Pixel& pix)
{
   int r, g, b;
   in >> r >> g >> b;
   pix.setRed(r);
   pix.setGreen(g);
   pix.setBlue(b);

return in;
}

^^^^

====
#define DOCTEST_CONFIG_IMPLEMENT_WITH_MAIN
#include "doctest.h"

TEST_CASE( "test1" ) {
    std::stringstream cout;
    int x = 3; int y = 7;
    cout << "The maximum is " << maximum(x, y);

std::string answer = "The maximum is 7";
    CHECK( cout.str() == answer );
}

TEST_CASE( "test2" ) {
    std::stringstream cout;
    std::string a = "raspberry"; std::string b = "jelly";
    cout << "The maximum is " << maximum(a, b);

std::string answer = "The maximum is raspberry";
    CHECK( cout.str() == answer );
}

TEST_CASE( "test3" ) {
    std::stringstream cout;
    double u = 3.14; double v = 1.0101;
    cout << "The maximum is " << maximum(u, v);

std::string answer = "The maximum is 3.14";
    CHECK( cout.str() == answer );
}

TEST_CASE( "test4" ) {
    std::stringstream cout;
    Pixel pix1(0, 1, 2); Pixel pix2(10, 9, 5);
    cout << "The maximum is " << maximum(pix1, pix2);

;
    std::string answer = "The maximum is 10 9 5";
    CHECK( cout.str() == answer );
}

🔗

CS223 Exercises

Section 1.10 Homework 10 -- Exception Handling and Function Templates

Exercises Exercises

1.

2.

3.

4.

5.

6.

7.

8.

9.

10.

11.

12.

13.

14.

15.