The rational.h Interface/Header File

// rational.h

#ifndef RATIONAL_H
#define RATIONAL_H

#include <iostream>

class Rational {
public:
	Rational(int num, int denom=1);
	Rational mul(const Rational &r) const;
	Rational &mulInPlace(const Rational &r);

	void print(std::ostream &os) const;
private:
	int num, denom;
};

inline std::ostream &operator <<(std::ostream &os, const Rational &r) {r.print(os); return os;}

#endif

The Include Guard/

#ifndef RATIONAL_H
#define RATIONAL_H

…

inline std::ostream &operator <<(std::ostream &os, const Rational &r) {r.print(os); return os;}

#endif

• Prevents multiple inclusion of the same header files
• Set macro to true; only continues reading source if the macro doesn't exit or is false
  • A macro is a value used by the preprocessor (the cpp program). It associate a name with a fragment of text; when the preprocessor encounters the name in text it is processing, it replaces it with the associated text
  • One of the applications of the preprocessor is conditional compilation; i.e., conditionally compiling source text based on some condition, in this case whether we've seen already seen this header file in the course of compilation
    • #ifdef tests the value of its conditional and returns true/false if the macro has / has-not been defined.
    • if false, compialtion skips the bidy of the conditional and resumes after the #endif
  • We use a naming convention for the macro: the name of the header file, in caps, with the . (invalid name character) replaced with an _ (valid name character).
• The include guard logic has been replaced for the most part with the pragma #pragma once
  • A pragma is an instruction (or directive) to the compiler. The once directive tells the compiler to only include the cuurent file once during this compilation

The Constructor

	…
	Rational(int num, int denom=1);
	…
};

• I've placed the definition of the constructor in the .cpp file for purposes of illustration.
  • Short, straightforward (i.e., simple, enumerated data member initialization) constructors are often coded inline in the class definition:

    // above -- in the body of the class definition in the header file
    Rationale(int num, int denom=1) : num(num), denom(denom) {}
    				

• C++ allows you to specify a default argument values; we've assigned the denominator a default of 1 here, allowing a simple way of specifying integer-valued Rationals.
  • The default value should typically appear in the function declaration (rather than definition)
  • The can be multiple default values, but once a default value is supplied, all parameters to it right must also have default values.

The Mulitplication Functions

	…
	Rational mul(const Rational &r) const;
	Rational &mulInPlace(const Rational &r);
	…

• As in the Java class, there are two multiplication operations: an in-place (mutable) function, mul; and an immutable ('non-mutating', 'out-of-place') function, mulInPlace.
• Both member functions consists of the receiver (the left operand) and a parameter of the same (Rational) type: r1.mul(r2) and r1.mulInPlace(r2)
• As mul returns a new Rational, it performs a return-by-value — it must return the result of the multiplication as a third Rational object.
  • This is one of the situations that we can't apply the standard transmission/return rules — we MUST return by value.
  • Hopefully we'll cover move constructors which address this very issue
• mulInPlace, on the other hand, can (and should) return a reference to the operand (typically the left one) whose value is being replaced.
  • Again, we provide a return type —despite the modification being made in-place — in order to provide for chaining: r1.mulInPlace(r2).mulInPlace(r3)
• For both functions, the parameter (i.e., the right-hand operand) is passed as const-reference … it's a class type and thus should have a reference passed rather the what may be a large expensive object to copy. As it should not be modified in either function, we add the const
• For the mulInPlace function the receiver (the left hand operand) is modified; but it isn't in mul function, and we'd like to indicate that fact, but there is no textual evidence for the receiver in the function header (the receiver is the implicit object upon which the function is called).
  • For constant receivers we add the const keyword after the parameter list in the declaration/header.
    • Notice that I've done the same for the print function; again the receiving object should not be modified by the function.

The print Function and << Operator

…
class Rational {
	…
	void print(std::ostream &os) const;
	…
};

inline std::ostream &operator <<(std::ostream &os, const Rational &r) {r.print(os); return os;}

• The parameter for the print function declaration is a reference, rather than a const-reference, as the ostream object is modified as we print to it.
• I've created a 1-line << operator for your convenience. It allows you to write

  cout << r1 << endl;
  	

  rather than:

  r1.printt(cout);
  cout << endl;
  	

The rational_app.cpp Application

#include 

#include "rational.h"

using namespace std;

int main() {
	Rational r1(1, 2), r2 {3};

	cout << "r1: ";
	r1.print(cout);
	cout << endl;
	
	cout << "r2: " << r2 << endl;

	Rational r3 = r1.mul(r2);
	cout << "r3: " << r3 << endl;

	r1.mulInPlace(r2);

	cout << "r1: " << r1 << endl;

	
	return 0;
}

• Notice the Rational objects are being directly declared and created as local objects. There is no creation on the heap.
  • These objects are created and destroyed (automatically) upon entrance to and exit from the function
• When printing r1, I showed how the object would be output in the absence of the << (insertion) operator; for the rest I used the insertion operator to illustrate its convenience.
• The declaration of r1 uses the 'classical' constructor-style direct initialization. It is also equivalent to writing:

  Rational r1 = Rational(1, 2);
  		

  and is thus also called functional notation.
• The declaration of r2 uses the 1-arg constructor, and direct-list initialization
  • This syntax is always legal as an initialization.

The rational.cpp Implementation File

#include <iostream>

#include "rational.h"
#include "rational_exception.h"

using namespace std;

Rational::Rational(int num, int denom) : num(num), denom(denom) {
	if (denom == 0) throw RationalException("0 denominator");
}

Rational Rational::mul(const Rational &r) const {
	Rational result = *this;
	return result.mulInPlace(r);
}

Rational &Rational::mulInPlace(const Rational &r) {
	num = num * r.num;
	denom = denom * r.denom;
	return *this;
}

void Rational::print(ostream &os) const {
	os << num;
	if (denom != 1)
		os << "/" << denom;
	else
		os << "";
}

The Multiplication Operations

Rational Rational::mul(const Rational &r) const {
	Rational result = *this;
	return result.mulInPlace(r);
}

Rational &Rational::mulInPlace(const Rational &r) {
	num = num * r.num;
	denom = denom * r.denom;
	return *this;
}

• Notice mul leverages mulInPlace. The straightforward (i.e., unleveraged) way to code mul would be:

  Rational Rational::mul(const Rational &r) const {
  	return Rational{num * r.num, denom * r.denom};	// or Rational(num * r.num, denom * r.denom);
  }
  		

  but then we'd have to be concerned that we've maintained semantic consistency of the multiplicatios in the two operations
  • leveraging 'guarantees' us the multiplication operation is the same in both cases.
• We could have reversed the leveraging:

  Rational Rational::mul(const Rational &r) const {
  	return Rational(num * r.num, denom * r.denom).normalize();
  }
  
  Rational& Rational::mulInPlace(const Rational &r) {
  	return *this = mul(r);        // assign from the new object
  }
  

Code Used in this Lecture