Description
Use Linux to create a user-defined Abstract Data Type (ADT) using a C++ class named Fraction along with an appropriate set of C++ header/implementation files as discussed in class.
The Fraction ADT must define and implement the following data types and operations. • Do not add to or modify the public interface (exportable components – public components). • Do not add to or modify any attributes or data types (storage components). Fraction class Exportable Operations: (declared .h file and defined .cpp file) Fraction default/parameterized constructor • 0 is the default numerator value – int (signed) • 1 is the default denominator value – int (unsigned) • if an invalid fraction is defined then use the default values Fraction copy constructor – creates an exact copy of an existing Fraction class instance ~Fraction destructor function – no dynamic memory used – does nothing (no message) getters/setters each private attribute includes an appropriate standard method getter/setter pair setters support default arguments implemented using explicit function inlining operator= assigns a passed in fraction to the invoking fraction a = b handle self-assignment operator+ adds a passed in fraction to the invoking fraction a + b operator* multiplies the invoking fraction by a passed in fraction a * b operator++ adds 1 to the invoking fraction ++a and a++ operator– negates the invoking fraction –a operator int converts the passed in fraction to int int( a ) operator float converts the passed in fraction to float float( a ) operator bool converts the passed in fraction to bool bool( a )
Fraction class Non-Exportable Operations: (declared .h file and defined .cpp file) reduce use where necessary at the end of operations to maintain a reduced fraction 2 / 6 = 1 / 3 14 / 10 = 7 / 5 – 21 / 7 = – 3 / 1 gcd returns the greatest common divisor – use an iterative implementation
Fraction class non-member Friend Operations: (declared .h file and define .cpp file) operator– subtracts a second passed in fraction from the first passed in fraction a – b operator/ divides a second passed in fraction into the first passed in fraction a / b operator– subtracts 1 from the passed in fraction –a and a– operator! inverts the passed in fraction !a
Fraction class non-member Operations: (declare .h file and define .cpp file) operator== true if both passed in fractions are equal a == b false otherwise operator< true if first passed in fraction is less than second passed in fraction a < b false otherwise operator true if first passed in fraction is greater than the second passed in fraction a b false otherwise operator<< replaces the view function from assignment 4 cout << a operator reads in the numerator and denominator values cin a prompt for values externally
Notes: • Think of how the operators affect primitive data type values. o E.g., is/are the value(s) applied to the operator modified by the operation? § a = b a is modified b is not modified § a + b a is not modified b is not modified • Do not allow the denominator to become 0 – provide appropriate user feedback. o Constructor uses defaults – 0/1 o Other operations – do not complete the operation – do not modify any instances Required Output Format (operator<<) // do not apply endl after // treat like any other value 0 0/1 // numerator 0 denominator 1 // cout << a << endl; 0 1/3 // numerator 1 denominator 3 - 0 2/5 // numerator –2 denominator 5 1 0/1 // numerator 1 denominator 1 2 1/4 // numerator 9 denominator 4 - 1 2/5 // numerator –7 denominator 5
Fraction resource web site: • https://www.helpwithfractions.com/ Only apply function inlining implementation techniques where stated. • All other functions are declared and defined using standard techniques supporting implementation hiding. Apply the const keyword “wherever” appropriate. • functions, arguments, … // E.g. getter, view, … functions Apply function reuse “everywhere” possible. • Think of how each of the operations is related to the other operations and apple reuse • E.g. increment can be implemented simply by using addition where the second value is 1 • E.g. subtract can be implemented simply by using negate and add with the second value • Some reuse will require the instantiation of temporary Fraction class instances
Make sure that you completely document the header/implementation files. • The header (.h) file tells the user exactly how to use your ADT o General descriptions only – do not include implementation details • The implementation file (.cpp) tells the implementer/programmer exactly how the ADT works o Detailed descriptions – include implementation details Add appropriate guards and macros to prevent multiple inclusions of the individual ADT modules.
The Fraction ADT exists entirely within the FractionNS namespace. • “Using Directive” to access the FractionNS namespace members – outside Fraction/Friend ADT only. • “Using Directive” to access the std namespace members: cin, cout, endl, etc… I will write a test program that will include your Fraction ADT so all header/implementation files tested must use common names. So you MUST use: • the EXACT same names for each data type and function in the header/implementation files. • the EXACT same function argument sequence in the header/implementation files.
Zip together and e-mail your Project Folder using the following naming convention. • Do not e-mail your main/driver program used for testing purposes o I will create my own main/driver program to test your ADT Archieve Name: Lastname5.zip or Lastname5.7z // I would use Gamradt5.zip Project Folder: Lastname5 // I would use Gamradt5 • Fraction.h Fraction class header file • Fraction.cpp Fraction class implementation file • main.cpp driver program file // I will use my own • CMakeLists.txt // No C++ 11 o Project name: Lastname5 // I would use Gamradt4 o Executable name: math List the class number, your Linux username, and assignment number as the e-mail message subject: SUBJECT: csc346 – gamradtk – a5 // I would use
Fraction/Friend ADT include sequence with multiple modules: // Never include .cpp files
main.cpp Fraction.h Fraction.cpp
Fraction ADT building with multiple modules: // Using cmake 1. Place all files in the project folder (see above) // I would use Gamradt5 2. cmake -G “Unix Makefiles” // Generate Makefile 3. cmake --build . // Build project – create executable 4. ./math // Run project
Note: when submitting remove all files and folders created by the build process • See above for required files in the submitted project folder