{"id":31,"date":"2024-08-01T18:35:48","date_gmt":"2024-08-01T18:35:48","guid":{"rendered":"https:\/\/bhiggs.x10hosting.com\/PracticalC%2B%2BProgramming\/?page_id=31"},"modified":"2025-01-20T20:21:56","modified_gmt":"2025-01-20T20:21:56","slug":"assignment-2","status":"publish","type":"page","link":"https:\/\/bhiggs.x10hosting.com\/PracticalCPlusPlusProgramming\/index.php\/assignments\/assignment-2\/","title":{"rendered":"Assignment 2"},"content":{"rendered":"\n

<\/span>A Rational Class<\/span><\/h2>\n\n\n\n
\n

Note:<\/strong><\/p>\n\n\n\n

This assignment is intended to give you some exposure to writing a relatively simple C++ class. In particular, it is intended to show you how much the C++ compiler is doing for you automatically — sometimes it does what you want, and sometimes not.<\/p>\n<\/blockquote>\n\n\n\n

<\/span>Rational Numbers<\/span><\/h3>\n\n\n\n

Rational numbers are those numbers that can be represented as ratios of integers:<\/p>\n\n\n\n

1\/2\t 57\/234\t -2\/3\t23\/405<\/code><\/pre>\n\n\n\n
(Note that all rational numbers are real numbers, but not all real numbers are, or can be, rational numbers.)<\/p>\n\n\n\n
<\/span>The Rational<\/code> Class<\/span><\/h4>\n\n\n\n
Implement a class Rational<\/strong>, which supports rational numbers. The class should support the following:<\/p>\n\n\n\n
    \n
  • Two int<\/code><\/strong> data members, numerator<\/code><\/strong> and denominator<\/code><\/strong>, which are private to the class. 
    These values will be kept in normalized<\/em> form; that is, the value of the denominator will be the smallest integer that can represent the ratio. For example, 3\/6 is not normalized; 1\/2 is: 3\/6 can be normalized by dividing both top and bottom by 3, to produce 1\/2. If the Rational<\/strong> is negative, then only the numerator is negative — the denominator is always positive. Clearly, the denominator should never be allowed to be zero.<\/li>\n\n\n\n
  • Initialization of a class instance from a single int<\/code><\/strong>. The value of the int<\/strong><\/code> will be the numerator of the ratio.<\/li>\n\n\n\n
  • Initialization of a class instance from two int<\/code><\/strong>s. The values of the two int<\/code><\/strong>s will be the numerator and the denominator of the ratio.<\/li>\n\n\n\n
  • Instance cleanup (if necessary; if not necessary, explain why not<\/em>)<\/li>\n\n\n\n
  • Initialization of a class instance from another instance of class Rational<\/strong>.<\/li>\n\n\n\n
  • Assignment of one Rational<\/strong> to another (how is this different from the above?<\/em>)<\/li>\n\n\n\n
  • Assignment of an int<\/code><\/strong> to a Rational<\/strong>.<\/li>\n\n\n\n
  • Assignment of a Rational<\/strong> to a double<\/code><\/strong>.<\/li>\n\n\n\n
  • Assignment of a double<\/code><\/strong> to a Rational<\/strong> should be prohibited<\/em><\/strong> (remember, mathematically, not all real numbers are rational numbers<\/em>).<\/li>\n\n\n\n
  • The addition of two Rational<\/strong>s (Rational<\/code><\/strong> + Rational<\/code><\/strong>) to produce another Rational<\/strong>.<\/li>\n\n\n\n
  • The addition of a Rational<\/strong> and a double<\/code><\/strong> (Rational<\/code><\/strong> + double<\/code><\/strong>) to produce a double<\/code><\/strong>.<\/li>\n\n\n\n
  • The addition of a double<\/strong><\/code> and a Rational<\/strong> (double<\/code><\/strong> + Rational<\/code><\/strong>) to produce a double<\/code><\/strong>.<\/li>\n\n\n\n
  • The subtraction of two Rational<\/strong>s (Rational<\/code><\/strong> – Rational<\/code><\/strong>) to produce another Rational<\/strong>.<\/li>\n\n\n\n
  • The subtraction of a double<\/code><\/strong> from a Rational<\/strong> (Rational<\/code><\/strong> – double<\/code><\/strong>) to produce a double<\/code><\/strong>.<\/li>\n\n\n\n
  • The subtraction of a Rational<\/strong> from a double<\/code><\/strong> (double<\/code><\/strong> – Rational<\/code><\/strong>) to produce a double<\/code><\/strong>.<\/li>\n\n\n\n
  • The multiplication of two Rational<\/strong>s (Rational<\/code><\/strong> * Rational<\/code><\/strong>) to produce another Rational<\/strong>.<\/li>\n\n\n\n
  • The multiplication of a Rationa<\/strong>l with a double<\/code><\/strong> (Rational<\/code><\/strong> * double<\/code><\/strong>) to produce a double<\/code><\/strong>.<\/li>\n\n\n\n
  • The multiplication of a double with a Rational<\/strong> (double<\/code><\/strong> * Rational<\/code><\/strong>) to produce a double<\/code><\/strong>.<\/li>\n\n\n\n
  • The division of two Rational<\/strong>s (Rational<\/code><\/strong> \/ Rational<\/code><\/strong>) to produce a Rational<\/strong>.<\/li>\n\n\n\n
  • The division of a Rational<\/strong> by a double<\/code><\/strong> (Rational<\/code><\/strong> \/ double<\/code><\/strong>) to produce a double<\/code><\/strong>.<\/li>\n\n\n\n
  • The division of a double by a Rational<\/strong> (double<\/code><\/strong> \/ Rational<\/code><\/strong>) to produce a double<\/code><\/strong>.<\/li>\n\n\n\n
  • The negation (unary minus) of a Rational<\/strong> (-Rational<\/code><\/strong>) to produce another Rational<\/strong>.<\/li>\n\n\n\n
  • The unary plus of a Rational<\/strong> (+Rational<\/code><\/strong>) to produce another Rational<\/strong>.<\/li>\n\n\n\n
  • A Print()<\/code><\/strong> member function that prints out the value of a Rational<\/strong> in its normalized form:<\/li>\n<\/ul>\n\n\n\n
    (3\/4)<\/code><\/strong>(including the parentheses)<\/em> <\/code><\/pre>\n\n\n\n
    <\/span>Strategy<\/span><\/h4>\n\n\n\n
    It is very tempting to implement the above by writing all the constructors, methods, operators, etc. from the start. However, you may be surprised how much will work ‘magically’! It is not necessary to map each of the above operations into a specific class method (or normal function, as the case may be). <\/p>\n\n\n\n
    I strongly suggest that you take a minimalist approach<\/em>: start with the smallest class you can, and work from there, incrementally. See how much that minimal class already supports, and understand why and how it supports it<\/em>. Then add what you need, as you discover what doesn’t work yet. As you add, keep trying to understand how the new stuff works (or why it doesn’t work), and how things change as you add that functionality.<\/em> Use this as a learning experience! (Please document what you did – as much for your own benefit, as for mine.<\/em>)<\/p>\n\n\n\n
    Here’s a suggested approach (Please provide answers to the questions!<\/strong><\/em>):<\/p>\n\n\n\n
    <\/span>Step 1<\/span><\/h5>\n\n\n\n
    Create, in file rational.h<\/code><\/strong>, a class Rational<\/strong>, with private data members numerator<\/code><\/strong> and denominator<\/code><\/strong>, and a private member function Normalize()<\/code><\/strong>, which does basic checking of numerator and denominator values, and reduces the ratio to its normal form (i.e. numerator<\/code><\/strong> and denominator<\/code><\/strong> contain the smallest possible integer values).

    Write a public constructor to construct a Rational<\/strong> from two int<\/code><\/strong>s, with appropriate default arguments, and a public member function Print()<\/code><\/strong>, to print out the Rational<\/strong> as described earlier (Print()<\/code><\/strong> will help with debugging…). In addition, create two public member functions, Numerator()<\/code><\/strong> and Denominator()<\/code><\/strong>. 

    Here’s the class to start off with:<\/p>\n\n\n\n
    \n
    \n
    <\/path><\/path><\/svg><\/span>
    \/\/<\/span><\/span>\n\/\/  rational.h<\/span><\/span>\n\/\/  Assignment 2: Rational Class<\/span><\/span>\n\/\/<\/span><\/span>\n\/\/  Created by Bryan Higgs on 10\/28\/24.<\/span><\/span>\n\/\/<\/span><\/span>\n<\/span>\n#ifndef<\/span> rational_h<\/span><\/span>\n#define<\/span> rational_h<\/span><\/span>\n<\/span>\nclass<\/span> <\/span>Rational<\/span><\/span>\n{<\/span><\/span>\n  <\/span>public:<\/span><\/span>\n    \/\/ Constructor<\/span><\/span>\n    <\/span>Rational<\/span>(<\/span>int<\/span> <\/span>num<\/span> = <\/span>0<\/span>, <\/span>int<\/span> <\/span>den<\/span> = <\/span>1<\/span>);<\/span> \/\/ <implement here><\/span><\/span>\n<\/span>\n    \/\/ Print out the contents of the instance<\/span><\/span>\n    <\/span>void<\/span> <\/span>Print<\/span>();<\/span>   \/\/ Implemented in the rational.cpp file<\/span><\/span>\n<\/span>\n    \/\/ Access member functions<\/span><\/span>\n    <\/span>int<\/span> <\/span>Numerator<\/span>()     { <\/span>return<\/span> m_num; }<\/span><\/span>\n    <\/span>int<\/span> <\/span>Denominator<\/span>()   { <\/span>return<\/span> m_den; }<\/span><\/span>\n<\/span>\n  <\/span>private:<\/span><\/span>\n    \/\/ Private functions<\/span><\/span>\n    <\/span>void<\/span> <\/span>Normalize<\/span>();<\/span> \/\/ To be implemented in the rational.cpp file<\/span><\/span>\n<\/span>\n    \/\/ Private data<\/span><\/span>\n    <\/span>int<\/span>  m_num;<\/span>    \/\/ numerator<\/span><\/span>\n    <\/span>int<\/span>  m_den;<\/span>    \/\/ denominator<\/span><\/span>\n};<\/span><\/span>\n<\/span>\n#endif<\/span> \/* rational_h *\/<\/span><\/span><\/code><\/pre><\/div>\n<\/div>\n\n\n\n
    \n
    Your job is to fill in the <implement here><\/strong>, and implement the Print()<\/code><\/strong> and Normalize()<\/code><\/strong> functions in the rational.cpp<\/code><\/strong> file.<\/p>\n\n\n\n
    Once you have completed this step, you should be able to do simple construction of Rational<\/strong> types. Try this out by writing a separate testrat.cpp<\/code><\/strong> file, which will include the rational.h<\/code><\/strong> file, and by linking the two objects produced from compiling the rational.cpp<\/code><\/strong> and the testrat.cpp<\/code><\/strong> files.<\/p>\n<\/div>\n<\/div>\n\n\n\n
    <\/span>Step 2<\/span><\/h5>\n\n\n\n
    Without adding anything else to your Rational<\/strong> class, try defining an instance of class Rational<\/strong>, initializing<\/em> it from another instance of class Rational<\/strong>. Does it work? If so, can you explain why?

    Now (again without adding anything to your class), try assigning<\/em> one instance of class Rational<\/strong> to another. Again, does it work? If so, why?<\/p>\n\n\n\n
    <\/span>Step 3<\/span><\/h5>\n\n\n\n
    What about assigning other types to an instance of class Rational<\/strong>? Try assigning an int<\/code><\/strong> (like the integer constant 3) to a Rational<\/strong>. Does it work? If so, why, and is it reasonably efficient? If not, how would you make it more efficient?

    What about assigning a double<\/code><\/strong> (like 45.6) to a Rational<\/strong>? Does it work? Should it work? <\/p>\n\n\n\n
    NO!<\/u><\/em><\/strong> In general, a double<\/code><\/strong> value cannot be expressed mathematically as an exact rational number. So how would you prevent this assignment from working?<\/p>\n\n\n\n
    <\/span>Step 4<\/span><\/h5>\n\n\n\n
    Now try assigning a Rational<\/strong> to a double<\/code><\/strong>. Does it work? Why?\/Why not? What will you do about it?

    Once you have double<\/code><\/strong> = Rational<\/code><\/strong> assignment working, try implementing the unary minus<\/em> and unary plus<\/em> operators:<\/p>\n\n\n\n
    -Rational\t\n+Rational<\/strong><\/code><\/pre>\n\n\n\n
    What should the type of this expression be? Does it work? What do you need to make it work?<\/p>\n\n\n\n
    <\/span>Step 5<\/span><\/h5>\n\n\n\n
    Now, try adding the binary (that is, 2-operand) arithmetic operations. <\/p>\n\n\n\n
    Start with addition<\/em>. First look at:<\/p>\n\n\n\n
    Rational + Rational<\/strong><\/code><\/pre>\n\n\n\n
    What should the type of this expression be? Does it work? What do you need to make it work?<\/p>\n\n\n\n
    Once you have Rational<\/code><\/strong>+Rational<\/code><\/strong> working, try:<\/p>\n\n\n\n
    Rational + double<\/strong><\/code><\/pre>\n\n\n\n
    What should the type of this expression be? What in fact happens, and why? How do you make this work?<\/p>\n\n\n\n
    Once you have Rational<\/code><\/strong>+double<\/code><\/strong> working, try reversing the order of the types:<\/p>\n\n\n\n
    double + Rational<\/strong><\/code><\/pre>\n\n\n\n
    What should the type of this expression be? Can you explain what you observe? What do you have to do to make this work?<\/p>\n\n\n\n
    Now implement subtraction<\/em>, multiplication<\/em> and division<\/em> for each of these combinations of types.<\/p>\n\n\n\n
    <\/span>Step 6<\/span><\/h5>\n\n\n\n
    Make sure that a call to a constructor Rational<\/code><\/strong>(double<\/code><\/strong>, double<\/code><\/strong>) — for example:<\/p>\n\n\n\n
    Rational r(3.0, 5.1);<\/strong><\/code><\/pre>\n\n\n\n
    (or any other case where such a constructor might be called, explicitly or implicitly) — fails<\/em><\/strong> at compile time.<\/p>\n\n\n\n
    <\/span>Step 7<\/span><\/h5>\n\n\n\n
    At this point, most operations should be working. Once you have cleaned up any that are not, you now have three things to do:<\/p>\n\n\n\n
      \n
    1. Check that each operation is indeed working, by thorough testing.<\/strong><\/li>\n\n\n\n
    2. Understand completely how each operation works.<\/strong><\/li>\n\n\n\n
    3. Determine whether each operation works sufficiently accurately<\/em> (no undue loss of precision) and efficiently<\/em> (no undue loss of performance).<\/strong><\/li>\n<\/ol>\n\n\n\n
      <\/span>How to Normalize<\/span><\/h4>\n\n\n\n
      You will find that the following code for evaluating the\u00a0greatest common divisor<\/em>\u00a0(GCD) of two integers will help you normalize your Rational<\/code><\/strong> class instances. I expect you to turn this code into a private member function of class Rational<\/code><\/strong>, called\u00a0Normalize()<\/code><\/strong>.<\/em><\/p>\n\n\n\n
      The function\u00a0Normalize()<\/code><\/strong> takes no arguments. <\/p>\n\n\n\n
      Here is some code that implements a\u00a0greatest common divisor<\/em>\u00a0function.\u00a0<\/p>\n\n\n\n
      \n
      \n
      <\/path><\/path><\/svg><\/span>
      \/\/<\/span><\/span>\n\/\/  gcd.cpp<\/span><\/span>\n\/\/  Assignment 2: Rational Class<\/span><\/span>\n\/\/<\/span><\/span>\n\/\/  Created by Bryan Higgs on 10\/31\/24.<\/span><\/span>\n\/\/<\/span><\/span>\n<\/span>\n\/\/<\/span><\/span>\n\/\/  Compute the greatest common divisor<\/span><\/span>\n\/\/  of two integers, m and n.<\/span><\/span>\n\/\/  (Uses Euclid's algorithm)<\/span><\/span>\n\/\/<\/span><\/span>\n<\/span>\nint<\/span> <\/span>gcd<\/span>(<\/span>int<\/span> <\/span>m<\/span>, <\/span>int<\/span> <\/span>n<\/span>)<\/span><\/span>\n{<\/span><\/span>\n  <\/span>if<\/span> ( (m == <\/span>0<\/span>) || (n == <\/span>0<\/span>) )<\/span><\/span>\n    <\/span>return<\/span> <\/span>1<\/span>;<\/span><\/span>\n<\/span>\n  <\/span>if<\/span> (m < <\/span>0<\/span>)<\/span><\/span>\n    m = -m;<\/span><\/span>\n  <\/span>if<\/span> (n < <\/span>0<\/span>)<\/span><\/span>\n    n = -n;<\/span><\/span>\n<\/span>\n  \/\/ Euclid's algorithm...<\/span><\/span>\n  <\/span>int<\/span> a, b, r;<\/span><\/span>\n<\/span>\n  <\/span>if<\/span> (n > m)<\/span><\/span>\n  {<\/span><\/span>\n    a = n;<\/span><\/span>\n    b = m;<\/span><\/span>\n  }<\/span><\/span>\n  <\/span>else<\/span><\/span>\n  {<\/span><\/span>\n    a = m;<\/span><\/span>\n    b = n;<\/span><\/span>\n  }<\/span><\/span>\n  r = <\/span>1<\/span>;<\/span><\/span>\n  <\/span>while<\/span> (r > <\/span>0<\/span>)<\/span><\/span>\n  {<\/span><\/span>\n    r = a % b;<\/span><\/span>\n    a = b;<\/span><\/span>\n    b = r;<\/span><\/span>\n  }<\/span><\/span>\n  <\/span>return<\/span> a;<\/span><\/span>\n}<\/span><\/span>\n<\/span>\n#ifdef<\/span> TESTING<\/span><\/span>\n\/\/ This code is included for testing purposes.<\/span><\/span>\n\/\/ Simply define the macro TESTING, and recompile this module;<\/span><\/span>\n\/\/ it will be a standalone program that tests the above function.<\/span><\/span>\n\/\/ Once you have completed the testing, undefine the macro TESTING,<\/span><\/span>\n\/\/ and recompile.<\/span><\/span>\n\/\/<\/span><\/span>\n\/\/ NOTE: Most C++ compilers provide a way of defining a macro at<\/span><\/span>\n\/\/       compile time.  If you are using a compiler from the command<\/span><\/span>\n\/\/       line, there is usually a switch of some kind (-D ?) to support<\/span><\/span>\n\/\/       this.  If you are using an IDE (Interactive Development<\/span><\/span>\n\/\/       Environment), you will have to learn how to define a macro at<\/span><\/span>\n\/\/       compile time from within the IDE.<\/span><\/span>\n<\/span>\n#include<\/span> <\/span><iostream><\/span><\/span>\n<\/span>\nstatic<\/span> <\/span>void<\/span> <\/span>print_gcd<\/span>(<\/span>int<\/span> <\/span>m<\/span>, <\/span>int<\/span> <\/span>n<\/span>)<\/span><\/span>\n{<\/span><\/span>\n  <\/span>std<\/span>::cout << <\/span>"GCD("<\/span> << m << <\/span>','<\/span> << n << <\/span>") = "<\/span> << <\/span>gcd<\/span>(m, n) << <\/span>'<\/span>\\n<\/span>'<\/span>;<\/span><\/span>\n}<\/span><\/span>\n<\/span>\nint<\/span> <\/span>main<\/span>(<\/span>int<\/span> <\/span>argc<\/span>, <\/span>const<\/span> <\/span>char<\/span> <\/span>*<\/span> <\/span>argv<\/span>[])<\/span><\/span>\n{<\/span><\/span>\n  <\/span>print_gcd<\/span>(<\/span>5<\/span>, <\/span>4<\/span>);<\/span><\/span>\n  <\/span>print_gcd<\/span>(<\/span>10<\/span>, <\/span>20<\/span>);<\/span><\/span>\n  <\/span>print_gcd<\/span>(<\/span>3<\/span>, <\/span>9<\/span>);<\/span><\/span>\n  <\/span>print_gcd<\/span>(<\/span>121<\/span>, <\/span>99<\/span>);<\/span><\/span>\n  <\/span>return<\/span> <\/span>0<\/span>;<\/span><\/span>\n}<\/span><\/span>\n#endif<\/span>  \/\/ TESTING<\/span><\/span><\/code><\/pre><\/div>\n<\/div>\n\n\n\n
      \n
      Change the\u00a0gcd()<\/code><\/strong>\u00a0function so that it becomes a member function of the class — when you make it a member function of the class, can you eliminate the m<\/code><\/strong> and n<\/code><\/strong> parameters?.<\/p>\n<\/div>\n<\/div>\n\n\n\n
      <\/span>Testing Your Program<\/span><\/h4>\n\n\n\n
      The following program should work correctly with your Rational<\/code><\/strong> class implementation. Test your class against this program, and verify the results against those expected.<\/p>\n\n\n\n
      \n
      \n
      <\/path><\/path><\/svg><\/span>
      \/\/<\/span><\/span>\n\/\/  testrat.cpp<\/span><\/span>\n\/\/  Assignment 2: Rational Class<\/span><\/span>\n\/\/<\/span><\/span>\n\/\/  Created by Bryan Higgs on 10\/31\/24.<\/span><\/span>\n\/\/<\/span><\/span>\n<\/span>\n#include<\/span> <\/span><iostream><\/span><\/span>\n#include<\/span> <\/span>"rational.h"<\/span><\/span>\n<\/span>\n\/\/<\/span><\/span>\n\/\/ Main program to test the Rational class<\/span><\/span>\n\/\/<\/span><\/span>\nint<\/span> <\/span>main<\/span>(<\/span>int<\/span> <\/span>argc<\/span>, <\/span>const<\/span> <\/span>char<\/span> <\/span>*<\/span> <\/span>argv<\/span>[])<\/span><\/span>\n{<\/span><\/span>\n <\/span>std<\/span>::cout << <\/span>std<\/span>::endl << <\/span>"====Check constructor with two ints:"<\/span>;<\/span><\/span>\n <\/span>std<\/span>::cout << <\/span>std<\/span>::endl << <\/span>"Rational a(3,4);"<\/span>;<\/span><\/span>\n Rational <\/span>a<\/span>(<\/span>3<\/span>,<\/span>4<\/span>);<\/span><\/span>\n <\/span>std<\/span>::cout << <\/span>std<\/span>::endl << <\/span>"a: "<\/span>;<\/span><\/span>\n <\/span>a<\/span>.<\/span>Print<\/span>();<\/span><\/span>\n<\/span>\n <\/span>std<\/span>::cout << <\/span>std<\/span>::endl << <\/span>"====Check constructor with one int:"<\/span>;<\/span><\/span>\n <\/span>std<\/span>::cout << <\/span>std<\/span>::endl << <\/span>"Rational b(3);"<\/span>;<\/span><\/span>\n Rational <\/span>b<\/span>(<\/span>3<\/span>);<\/span><\/span>\n <\/span>std<\/span>::cout << <\/span>std<\/span>::endl << <\/span>"b: "<\/span>;<\/span><\/span>\n <\/span>b<\/span>.<\/span>Print<\/span>();<\/span><\/span>\n<\/span>\n <\/span>std<\/span>::cout << <\/span>std<\/span>::endl << <\/span>"====Check copy constructor:"<\/span>;<\/span><\/span>\n <\/span>std<\/span>::cout << <\/span>std<\/span>::endl << <\/span>"Rational c(b);"<\/span>;<\/span><\/span>\n Rational <\/span>c<\/span>(b);<\/span><\/span>\n <\/span>std<\/span>::cout << <\/span>std<\/span>::endl <<<\/span>"c: "<\/span>;<\/span><\/span>\n <\/span>c<\/span>.<\/span>Print<\/span>();<\/span><\/span>\n<\/span>\n <\/span>std<\/span>::cout << <\/span>std<\/span>::endl << <\/span>"====Check Rational = Rational assignment:"<\/span>;<\/span><\/span>\n <\/span>std<\/span>::cout << <\/span>std<\/span>::endl << <\/span>"a = b;"<\/span>;<\/span><\/span>\n a = b;<\/span><\/span>\n <\/span>std<\/span>::cout << <\/span>std<\/span>::endl << <\/span>"a: "<\/span>;<\/span><\/span>\n <\/span>a<\/span>.<\/span>Print<\/span>();<\/span><\/span>\n<\/span>\n <\/span>std<\/span>::cout << <\/span>std<\/span>::endl << <\/span>"====Check Rational = int assignment:"<\/span>;<\/span><\/span>\n <\/span>std<\/span>::cout << <\/span>std<\/span>::endl << <\/span>"a = 1;"<\/span>;<\/span><\/span>\n a = <\/span>1<\/span>;<\/span><\/span>\n <\/span>std<\/span>::cout << <\/span>std<\/span>::endl << <\/span>"a: "<\/span>;<\/span><\/span>\n <\/span>a<\/span>.<\/span>Print<\/span>();<\/span><\/span>\n<\/span>\n#ifdef<\/span> CHECK_ERRORS<\/span> \/\/ Define CHECK_ERRORS to test this<\/span><\/span>\n <\/span>std<\/span>::cout << <\/span>std<\/span>::endl << <\/span>"====Check Rational = double assignment:"<\/span><\/span>\n         <\/span>" (Should not work!):"<\/span>;<\/span><\/span>\n <\/span>std<\/span>::cout << <\/span>std<\/span>::endl << <\/span>"a = 1.0;"<\/span>;<\/span><\/span>\n a = <\/span>1.0<\/span>;<\/span>  \/\/ Should not compile<\/span><\/span>\n <\/span>std<\/span>::cout << <\/span>std<\/span>::endl << <\/span>"a: "<\/span>;<\/span><\/span>\n <\/span>a<\/span>.<\/span>Print<\/span>();<\/span><\/span>\n#endif<\/span><\/span>\n<\/span>\n <\/span>std<\/span>::cout << <\/span>std<\/span>::endl << <\/span>"====Check double = Rational assignment:"<\/span>;<\/span><\/span>\n <\/span>std<\/span>::cout << <\/span>std<\/span>::endl << <\/span>"x = Rational(3,4);"<\/span>;<\/span><\/span>\n <\/span>double<\/span> x;<\/span><\/span>\n x = <\/span>Rational<\/span>(<\/span>3<\/span>,<\/span>4<\/span>);<\/span><\/span>\n <\/span>std<\/span>::cout << <\/span>std<\/span>::endl << <\/span>"x: "<\/span> << x;<\/span><\/span>\n<\/span>\n <\/span>std<\/span>::cout << <\/span>std<\/span>::endl << <\/span>"====Check Rational + Rational addition:"<\/span>;<\/span><\/span>\n <\/span>std<\/span>::cout << <\/span>std<\/span>::endl << <\/span>"c = Rational(3,4) + Rational(1,4);"<\/span>;<\/span><\/span>\n c = <\/span>Rational<\/span>(<\/span>3<\/span>,<\/span>4<\/span>) + <\/span>Rational<\/span>(<\/span>1<\/span>,<\/span>4<\/span>);<\/span><\/span>\n <\/span>std<\/span>::cout << <\/span>std<\/span>::endl << <\/span>"c: "<\/span>;<\/span><\/span>\n <\/span>c<\/span>.<\/span>Print<\/span>();<\/span><\/span>\n<\/span>\n <\/span>std<\/span>::cout << <\/span>std<\/span>::endl << <\/span>"====Check double + Rational addition:"<\/span>;<\/span><\/span>\n <\/span>std<\/span>::cout << <\/span>std<\/span>::endl << <\/span>"x = 37.25 + Rational(3,4);"<\/span>;<\/span><\/span>\n x = <\/span>37.25<\/span> + <\/span>Rational<\/span>(<\/span>3<\/span>,<\/span>4<\/span>);<\/span><\/span>\n <\/span>std<\/span>::cout << <\/span>std<\/span>::endl << <\/span>"x: "<\/span> << x;<\/span><\/span>\n<\/span>\n <\/span>std<\/span>::cout << <\/span>std<\/span>::endl << <\/span>"====Check Rational + double addition:"<\/span>;<\/span><\/span>\n <\/span>std<\/span>::cout << <\/span>std<\/span>::endl << <\/span>"x = Rational(3,4) + 37.25;"<\/span>;<\/span><\/span>\n x = <\/span>Rational<\/span>(<\/span>3<\/span>,<\/span>4<\/span>) + <\/span>37.25<\/span>;<\/span><\/span>\n <\/span>std<\/span>::cout << <\/span>std<\/span>::endl << <\/span>"x: "<\/span> << x;<\/span><\/span>\n<\/span>\n <\/span>std<\/span>::cout << <\/span>std<\/span>::endl << <\/span>"====Check Rational - Rational subtraction:"<\/span>;<\/span><\/span>\n <\/span>std<\/span>::cout << <\/span>std<\/span>::endl << <\/span>"c = Rational(3,4) - Rational(1,4);"<\/span>;<\/span><\/span>\n c = <\/span>Rational<\/span>(<\/span>3<\/span>,<\/span>4<\/span>) - <\/span>Rational<\/span>(<\/span>1<\/span>,<\/span>4<\/span>);<\/span><\/span>\n <\/span>std<\/span>::cout << <\/span>std<\/span>::endl << <\/span>"c: "<\/span>;<\/span><\/span>\n <\/span>c<\/span>.<\/span>Print<\/span>();<\/span><\/span>\n<\/span>\n <\/span>std<\/span>::cout << <\/span>std<\/span>::endl << <\/span>"====Check double - Rational subtraction:"<\/span>;<\/span><\/span>\n <\/span>std<\/span>::cout << <\/span>std<\/span>::endl << <\/span>"x = 37.25 - Rational(3,4);"<\/span>;<\/span><\/span>\n x = <\/span>37.25<\/span> - <\/span>Rational<\/span>(<\/span>3<\/span>,<\/span>4<\/span>);<\/span><\/span>\n <\/span>std<\/span>::cout << <\/span>std<\/span>::endl << <\/span>"x: "<\/span> << x;<\/span><\/span>\n<\/span>\n <\/span>std<\/span>::cout << <\/span>std<\/span>::endl << <\/span>"====Check Rational - double subtraction:"<\/span>;<\/span><\/span>\n <\/span>std<\/span>::cout << <\/span>std<\/span>::endl << <\/span>"x = Rational(3,4) - 37.25;"<\/span>;<\/span><\/span>\n x = <\/span>Rational<\/span>(<\/span>3<\/span>,<\/span>4<\/span>) - <\/span>37.25<\/span>;<\/span><\/span>\n <\/span>std<\/span>::cout << <\/span>std<\/span>::endl << <\/span>"x: "<\/span> << x;<\/span><\/span>\n<\/span>\n <\/span>std<\/span>::cout << <\/span>std<\/span>::endl << <\/span>"====Check Rational * Rational multiplication:"<\/span>;<\/span><\/span>\n <\/span>std<\/span>::cout << <\/span>std<\/span>::endl << <\/span>"c = Rational(3,4) * Rational(1,4);"<\/span>;<\/span><\/span>\n c = <\/span>Rational<\/span>(<\/span>3<\/span>,<\/span>4<\/span>) * <\/span>Rational<\/span>(<\/span>1<\/span>,<\/span>4<\/span>);<\/span><\/span>\n <\/span>std<\/span>::cout << <\/span>std<\/span>::endl << <\/span>"c: "<\/span>;<\/span><\/span>\n <\/span>c<\/span>.<\/span>Print<\/span>();<\/span><\/span>\n<\/span>\n <\/span>std<\/span>::cout << <\/span>std<\/span>::endl << <\/span>"====Check double * Rational multiplication:"<\/span>;<\/span><\/span>\n <\/span>std<\/span>::cout << <\/span>std<\/span>::endl << <\/span>"x = 37.25 * Rational(3,4);"<\/span>;<\/span><\/span>\n x = <\/span>37.25<\/span> * <\/span>Rational<\/span>(<\/span>3<\/span>,<\/span>4<\/span>);<\/span><\/span>\n <\/span>std<\/span>::cout << <\/span>std<\/span>::endl << <\/span>"x: "<\/span> << x;<\/span><\/span>\n<\/span>\n <\/span>std<\/span>::cout << <\/span>std<\/span>::endl << <\/span>"====Check Rational * double multiplication:"<\/span>;<\/span><\/span>\n <\/span>std<\/span>::cout << <\/span>std<\/span>::endl << <\/span>"x = Rational(3,4) * 37.25;"<\/span>;<\/span><\/span>\n x = <\/span>Rational<\/span>(<\/span>3<\/span>,<\/span>4<\/span>) * <\/span>37.25<\/span>;<\/span><\/span>\n <\/span>std<\/span>::cout << <\/span>std<\/span>::endl << <\/span>"x: "<\/span> << x;<\/span><\/span>\n<\/span>\n <\/span>std<\/span>::cout << <\/span>std<\/span>::endl << <\/span>"====Check Rational \/ Rational division:"<\/span>;<\/span><\/span>\n <\/span>std<\/span>::cout << <\/span>std<\/span>::endl << <\/span>"c = Rational(3,4) \/ Rational(1,4);"<\/span>;<\/span><\/span>\n c = <\/span>Rational<\/span>(<\/span>3<\/span>,<\/span>4<\/span>) \/ <\/span>Rational<\/span>(<\/span>1<\/span>,<\/span>4<\/span>);<\/span><\/span>\n <\/span>std<\/span>::cout << <\/span>std<\/span>::endl << <\/span>"c: "<\/span>;<\/span><\/span>\n <\/span>c<\/span>.<\/span>Print<\/span>();<\/span><\/span>\n<\/span>\n <\/span>std<\/span>::cout << <\/span>std<\/span>::endl << <\/span>"====Check double \/ Rational division:"<\/span>;<\/span><\/span>\n <\/span>std<\/span>::cout << <\/span>std<\/span>::endl << <\/span>"x = 37.25 \/ Rational(3,4);"<\/span>;<\/span><\/span>\n x = <\/span>37.25<\/span> \/ <\/span>Rational<\/span>(<\/span>3<\/span>,<\/span>4<\/span>);<\/span><\/span>\n <\/span>std<\/span>::cout << <\/span>std<\/span>::endl << <\/span>"x: "<\/span> << x;<\/span><\/span>\n<\/span>\n <\/span>std<\/span>::cout << <\/span>std<\/span>::endl << <\/span>"====Check Rational \/ double division:"<\/span>;<\/span><\/span>\n <\/span>std<\/span>::cout << <\/span>std<\/span>::endl << <\/span>"x = Rational(3,4) \/ 37.25;"<\/span>;<\/span><\/span>\n x = <\/span>Rational<\/span>(<\/span>3<\/span>,<\/span>4<\/span>) \/ <\/span>37.25<\/span>;<\/span><\/span>\n <\/span>std<\/span>::cout << <\/span>std<\/span>::endl << <\/span>"x: "<\/span> << x;<\/span><\/span>\n<\/span>\n <\/span>std<\/span>::cout << <\/span>std<\/span>::endl << <\/span>"====Check Rational negation:"<\/span>;<\/span><\/span>\n <\/span>std<\/span>::cout << <\/span>std<\/span>::endl << <\/span>"c = -Rational(3,4);"<\/span>;<\/span><\/span>\n c = -<\/span>Rational<\/span>(<\/span>3<\/span>,<\/span>4<\/span>);<\/span><\/span>\n <\/span>std<\/span>::cout << <\/span>std<\/span>::endl << <\/span>"c: "<\/span>;<\/span><\/span>\n <\/span>c<\/span>.<\/span>Print<\/span>();<\/span><\/span>\n<\/span>\n <\/span>std<\/span>::cout << <\/span>std<\/span>::endl << <\/span>"====Check Rational unary plus:"<\/span>;<\/span><\/span>\n <\/span>std<\/span>::cout << <\/span>std<\/span>::endl << <\/span>"c = +Rational(3,4);"<\/span>;<\/span><\/span>\n c = +<\/span>Rational<\/span>(<\/span>3<\/span>,<\/span>4<\/span>);<\/span><\/span>\n <\/span>std<\/span>::cout << <\/span>std<\/span>::endl << <\/span>"c: "<\/span>;<\/span><\/span>\n <\/span>c<\/span>.<\/span>Print<\/span>();<\/span><\/span>\n<\/span>\n <\/span>std<\/span>::cout << <\/span>std<\/span>::endl << <\/span>"====Destructors about to be checked...<\/span>\\n<\/span>"<\/span>;<\/span><\/span>\n  <\/span><\/span>\n <\/span>return<\/span> <\/span>0<\/span>;<\/span><\/span>\n}<\/span><\/span><\/code><\/pre><\/div>\n<\/div>\n\n\n\n
      <\/div>\n<\/div>\n","protected":false},"excerpt":{"rendered":"
      A Rational Class Note: This assignment is intended to give you some exposure to writing a relatively simple C++ class. In particular, it is intended to show you how much the C++ compiler is doing for you automatically — sometimes it does what you want, and sometimes not. Rational Numbers Rational numbers are those numbers […]<\/p>\n","protected":false},"author":1,"featured_media":0,"parent":29,"menu_order":0,"comment_status":"closed","ping_status":"closed","template":"","meta":{"footnotes":""},"class_list":["post-31","page","type-page","status-publish","hentry"],"blocksy_meta":[],"_links":{"self":[{"href":"https:\/\/bhiggs.x10hosting.com\/PracticalCPlusPlusProgramming\/index.php\/wp-json\/wp\/v2\/pages\/31","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/bhiggs.x10hosting.com\/PracticalCPlusPlusProgramming\/index.php\/wp-json\/wp\/v2\/pages"}],"about":[{"href":"https:\/\/bhiggs.x10hosting.com\/PracticalCPlusPlusProgramming\/index.php\/wp-json\/wp\/v2\/types\/page"}],"author":[{"embeddable":true,"href":"https:\/\/bhiggs.x10hosting.com\/PracticalCPlusPlusProgramming\/index.php\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/bhiggs.x10hosting.com\/PracticalCPlusPlusProgramming\/index.php\/wp-json\/wp\/v2\/comments?post=31"}],"version-history":[{"count":3,"href":"https:\/\/bhiggs.x10hosting.com\/PracticalCPlusPlusProgramming\/index.php\/wp-json\/wp\/v2\/pages\/31\/revisions"}],"predecessor-version":[{"id":1597,"href":"https:\/\/bhiggs.x10hosting.com\/PracticalCPlusPlusProgramming\/index.php\/wp-json\/wp\/v2\/pages\/31\/revisions\/1597"}],"up":[{"embeddable":true,"href":"https:\/\/bhiggs.x10hosting.com\/PracticalCPlusPlusProgramming\/index.php\/wp-json\/wp\/v2\/pages\/29"}],"wp:attachment":[{"href":"https:\/\/bhiggs.x10hosting.com\/PracticalCPlusPlusProgramming\/index.php\/wp-json\/wp\/v2\/media?parent=31"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}