UMBC CS 201, Fall 05
 UMBC CMSC 201 Fall '05 CSEE | 201 | 201 F'05 | lectures | news | help Search Notes:

## Example: Fractions

A fraction consists of a numerator and denominator and is used when discussing parts of a whole.

Example: The fraction 1/2 means that if an object is divided into two equal parts, then we are working with one of those parts.

The 1 is known as the numerator and the 2 is known as the denominator. Both the numerator and denominator of a fraction are integers. The denominator cannot be 0.

When working with fractions, we are sometimes interested in a whole number as well, as in 5/4 = 1 1/4. Numbers expressed as fractions can have a whole number part as well as a fractional part.

The operations on fractions include :

• subtraction
• multiplication
• division
• reduce to lowest terms
• find least common denominator
• etc.
Since we have just defined a mathematical object (the fraction) and the operations on that object, we can say that a fraction is an abstract data type.

#### Example implementation of a fraction:

A fraction could be a structure that has three members, all of type int. One member would be the whole number part and the other members would be the numerator and the denominator.

Fractions have many operations on them, which could all be written as functions. Standard practice is to write an interface (the .h file) called fraction.h that contains both the definition of the fraction structure and prototypes for all of the functions (the operations on fractions) with detailed explanations of the functions.

/************************************************\ * Filename: frac1.h * * Author: Sue Bogar * * Date Written: 4/14/98 * * Modified: 11/20/05 * * Section: 101 * * EMail: bogar@cs.umbc.edu * * * * Description: * * This header file contains the structure * * definition for a fraction type called FRACTION * * and the function prototypes for the functions * * defined in frac1.c, the implementation of the * * ADT fraction. This example is NOT meant to be * * a good example of an interface since it * * doesn't have any of the descriptions of the * * type FRACTION or of the functions. * \************************************************/ typedef struct fraction { int whole; int numerator; int denominator; } FRACTION; typedef FRACTION* FRACTPTR; void AddFractions (FRACTPTR fPtr1, FRACTPTR fPtr2, FRACTPTR sumPtr); void SubFractions (FRACTPTR fPtr1, FRACTPTR fPtr2, FRACTPTR differencePtr); void MultFractions (FRACTPTR fPtr1, FRACTPTR fPtr2, FRACTPTR productPtr); void DivFractions (FRACTPTR fPtr1, FRACTPTR fPtr2, FRACTPTR quotientPtr); void RedToLowTerms (FRACTPTR fPtr); . . .

#### Alternative implementation of a fraction:

A fraction could be an array of ints that always had three elements, where the whole number part would always be stored at FRACTION[0], the numerator would be held in FRACTION[1], and the denominator in FRACTION[2].

Fractions have many operations on them, which could all be written as functions. Standard practice is to write an interface (the .h file) called fraction.h that contains both the definition of the fraction and prototypes for all of the functions (the operations on fractions) with detailed explanations of the functions.

/**************************************************\ * Filename: frac2.h * * Author: Sue Bogar * * Date Written: 4/14/98 * * Modified: 11/20/05 * * Section: 101 * * EMail: bogar@cs.umbc.edu * * * * Description: This header file contains the * * typedef of a FRACTION type, using an array of * * ints and the function prototypes for the * * functions defined in frac2.c, the implementation * * of the ADT fraction. This example is NOT meant * * to be a good example of an interface since it * * doesn't have any descriptions of the type * * FRACTION or of the functions. * \**************************************************/ #define SIZE 3 typedef int FRACTION [SIZE]; void AddFractions (FRACTION f1, FRACTION f2, FRACTION sum); void SubFractions (FRACTION f1, FRACTION f2, FRACTION difference); void MultFractions (FRACTION f1, FRACTION f2, FRACTION product); void DivFractions (FRACTION f1, FRACTION f2, FRACTION quotient); void RedToLowTerms (FRACTION f1); . . .

#### Differences in Implemetation

The functions that are operations on fractions should have the same names in either implementation. The functions may (or may not) take different types of arguments, but they will do the same things even though the code in each function will be significantly different from its counterpart using the other implementation.

Typically, abstract data types are somewhat complicated as are most things in life. Until we covered structures, we were unable to envision ways of handling most abstract data types. Although some abstract data types can be implemented with arrays, most are implemented with structures. Obviously, the more complex the ADT, the more complex the structure becomes.

CSEE | 201 | 201 F'05 | lectures | news | help

Sunday, 20-Nov-2005 18:07:37 EST