1

Introduction

Previously, programmers starting a project would sit down almost immediately and start writing code. As programming projects became large and more complicated, it was found that this approach did not work very well. The problem was complexity. Large programs are probably the most complicated entities ever created by humans. Because of this complexity, programs are prone to error, and software errors can be expensive and even life threatening (in air traffic control, for example). Three major innovations in programming have been devised to cope with the problem of complexity. They are

Introduction

Object-oriented programming (OOP) The Unified Modeling Language (UML) Improved software development processes

You will be taught the C++ language with these developments in mind. You will not only learn a computer language, but new ways of conceptualizing software development. Other famous Object Oriented languages are JAVA, C# (C Charp), VB.NET (Visual Basic Dot Net), Paython3, PHP5.

Object Oriented Programming

Object Oriented Programming offers a new and powerful way to cope with complexity. Instead of viewing a program as a series of steps to be carried out, it views it as a group of objects that have certain properties and can take certain actions. This may sound obscure until you learn more about it, but it results in programs that are clearer, more reliable, and more easily maintained. A major goal of this course is to teach object-oriented programming using C++ and cover all its major features.

The Unified Modeling Language

The Unified Modeling Language (UML) is a graphical language consisting of many kinds of diagrams. It helps program analysts figure out what a program should do, and helps programmers design and understand how a program works. The UML is a powerful tool that can make programming easier and more effective. We introduce each UML feature where it will help to clarify the OOP topic being discussed. In this way you learn the UML painlessly at the same time the UML helps you to learn C++.
5

Class

A class serves as a plan, or template. It specifies what data and what functions will be included in objects of that class. Defining the class doesnt create any objects, just as the type int doesnt create any variables. A class is thus a description of a number of similar objects. Prince, Sting, and Madonna are members of the class of rock musicians. There is no one person called rock musician but specific people with specific names are members of this class if they possess certain characteristics.
6

Class

Picture a programming object just like any normal object in the real world. Each real world object has its own properties and specific things that you can do with it. For example, a bow has specific properties such as color, number of arrows, and weight and specific capabilities such as the ability to fire .
7

Class

two Bow objects are declared using the Bow class, the Bow class describes the properties of a bow, each of the two Bow objects has distinct values for these properties

A Simple Class
// smallobj.cpp demonstrates a small, simple object #include <iostream> using namespace std; class smallobj // define a class (a concept) { private: int somedata; // class data (attributes) public: void setdata(int d){ // member function (method)to somedata = d; // set data } void showdata(){ // member function to display data cout << "Data is " << somedata << endl; } };
9

A Simple Class
int main() { smallobj s1, s2; // define two objects of class smallobj s1.setdata(1066); // call member function to set data s2.setdata(1776); s1.showdata(); // call member function to display data s2.showdata(); system("PAUSE"); return 0; }

10

Classes and Objects

An object has the same relationship to a class that a variable has to a data type. An object is said to be an instance of a class, in the same way my 1954 Chevrolet is an instance of a vehicle. In the program the class , whose name is smallobj, is defined in the first part of the program. In main(), we define two objects s1 and s2 that are instances of that class. Each of the two objects is given a value, and each displays its value.
11

Defining the Class

Syntax for class definition

12

Defining the Class

The definition starts with the keyword class, followed by the class namesmallobj in this Example. The body of the class is delimited by braces and terminated by a semicolon. An object has the same relationship to a class that a variable has to a data type. A key feature of object-oriented programming is data hiding. it means that data is concealed within a class so that it cannot be accessed mistakenly by functions outside the class. The primary mechanism for hiding data is to put it in a class and make it private.

13

Defining the Class

Private data or functions can only be accessed from within the class. Public data or functions, on the other hand, are accessible from outside the class. The data member somedata follows the keyword private, so it can be accessed from within the class, but not from outside. Member functions (also called methods or messages) are functions that are included within a class. There are two member functions in smallobj: setdata() and showdata().
14

Defining the Class

Because setdata() and showdata() follow the keyword public, they can be accessed from outside the class. In a class the functions do not occupy memory until an object of the class is created.
15

Defining the Class

Remember that the definition of the class smallobj does not create any objects. It only describes how they will look when they are created. Defining objects means creating them. This is also called instantiating them, because an instance of the class is created. An object is an instance of a class. s1.setdata(1066); This syntax is used to call a member function that is associated with a specific object s1. Member functions of a class can be accessed only by an object of that class.

16

Widget Parts as Objects

(1/2)

// objpart.cpp widget part as an object #include <iostream> using namespace std; class part{ // define class private: int modelnumber; // ID number of widget int partnumber; // ID number of widget part float cost; // cost of part public: void setpart(int mn, int pn, float c){ // set data modelnumber = mn; partnumber = pn; cost = c; } void showpart(){ // display data cout << "Model " << modelnumber;
17

Widget Parts as Objects

}

(1/2)

cout << ", part " << partnumber; cout << ", costs $" << cost << endl;

};
int main(){ part part1; // define object of class part part1.setpart(6244, 373, 217.55F); // call member function part1.showpart(); // call member function system("PAUSE"); return 0; }

If you were designing an inventory program you might actually want to create a class something like part. Its an example of a C++ object representing a physical object in the real worlda widget part.

18

Circles as Objects
// circles.cpp circles as graphics objects #include "msoftcon.h" // for graphics functions class circle{ // graphics circle protected: int xCo, yCo; // coordinates of center int radius; color fillcolor; // color fstyle fillstyle; // fill pattern public: // sets circle attributes void set(int x, int y, int r, color fc, fstyle fs){ xCo = x; yCo = y; radius = r; fillcolor = fc; fillstyle = fs; } void draw(){ // draws the circle set_color(fillcolor); // set color set_fill_style(fillstyle); // set fill
19

Circles as Objects
draw_circle(xCo, yCo, radius);// draw solid circle } }; int main(){ init_graphics(); // initialize graphics system circle c1, c2, c3; // create circles //set circle attributes c1.set(15, 7, 5, cBLUE, X_FILL); c2.set(41, 12, 7, cRED, O_FILL); c3.set(65, 18, 4, cGREEN, MEDIUM_FILL); c1.draw(); //draw circles c2.draw(); c3.draw(); set_cursor_pos(1, 25); // lower left corner system("PAUSE"); return 0; }

20

Using Class to Represent Distances

// englobj.cpp objects using English measurements #include <iostream> using namespace std; class Distance{ // English Distance class private: int feet; float inches; public: void setdist(int ft, float in) // set Distance to args { feet = ft; inches = in; } void getdist(){ // get length from user cout << "\nEnter feet: "; cin >> feet; cout << "Enter inches: "; cin >> inches; } void showdist() // display distance { cout << feet << "\-" << inches << '\'; } }; 21

Using Class to Represent Distances

int main() { Distance dist1, dist2; dist1.setdist(11, 6.25); dist2.getdist(); // display lengths cout << "\ndist1 = "; dist1.showdist(); cout << "\ndist2 = "; dist2.showdist(); cout << endl; system("PAUSE"); return 0; // define two lengths // set dist1 // get dist2 from user

22

Constructors

We see that member functions can be used to give values to the data items in an object. Sometimes, however, its convenient if an object can initialize itself when its first created, without requiring a separate call to a member function. Automatic initialization is carried out using a special member function called a constructor. A constructor is a member function that is executed automatically whenever an object is created. Constructor has the same name of class and it has no return type.
23

Constructors: Count Example (1/2)

// counter.cpp object represents a counter variable #include <iostream> using namespace std; class Counter{ private: unsigned int count; // count public: Counter() : count(0) // constructor { cout << "constructor has been called \n"; } void inc_count() { count++; } int get_count() { return count; } };
24

// increment count

// return count

Constructors: Count Example (2/2)

int main() { Counter c1, c2; cout << "\nc1=" << cout << "\nc2=" << c1.inc_count(); c2.inc_count(); c2.inc_count(); cout << "\nc1=" << cout << "\nc2=" << cout << endl; system("PAUSE"); return 0; } // define and initialize // display // // // // increment c1 increment c2 increment c2 display again

c1.get_count(); c2.get_count();

c1.get_count(); c2.get_count();

25

Circles using Constructor

(1/2)

// circles.cpp circles as graphics objects #include "msoftcon.h" // for graphics functions class circle{ // graphics circle protected: int xCo, yCo; // coordinates of center int radius; color fillcolor; // color fstyle fillstyle; // fill pattern public: // sets circle attributes circle(int x, int y, int r, color fc, fstyle fs): xCo(x), yCo(y), radius(r), fillcolor(fc), fillstyle(fs) { } // 3 argument constructor void draw(){ // draws the circle set_color(fillcolor); // set color set_fill_style(fillstyle); // set fill
26

Circles using Constructor

}

(2/2)

draw_circle(xCo, yCo, radius); //draw solid circle }; int main(){ init_graphics(); // initialize graphics system //create circles circle c1(15, 7, 5, cBLUE, X_FILL); circle c2(41, 12, 7, cRED, O_FILL); circle c3(65, 18, 4, cGREEN, MEDIUM_FILL); c1.draw(); // draw circles c2.draw(); c3.draw(); set_cursor_pos(1, 25); // lower left corner return 0; }
27

Destructor

You might guess that another function is called automatically when an object is destroyed. This is indeed the case. Such a function is called a destructor. A destructor also has the same name as the class name but is preceded by a tilde (~) sign: Like constructors, destructors do not have a return value. They also take no arguments. The most common use of destructors is to de-allocate memory that was allocated for the object by the constructor.

28

Using Destructor
// foo.cpp demonstrates destructor #include <iostream> using namespace std; class Foo{ private: int data; public: Foo() : data(0) // constructor (same name as class) {cout<< "Wakeup \n" ; } ~Foo() // destructor (same name with tilde) {cout<< "ByeBye \n" ; } }; int main(){ Foo s1, s2; // define two objects of class Foo system( "PAUSE" ); // Foo *s3; s3 = new Foo; delete s3; return 0; } 29

Objects as Function Arguments

Next program demonstrates some new aspects of classes, which are:

Constructor Overloading
Defining Member Functions Outside The Class

Objects

as Function Arguments.

30

Objects as Function Arguments (1/3)

// englcon.cpp constructors, adds objects using member function #include <iostream> using namespace std; class Distance // English Distance class { private: int feet; float inches; public: // constructor (no args) Distance() : feet(0), inches(0.0) { cout<< "No Arguments Constructor has been Called \n" ; } //constructor (two args) Distance(int ft, float in) : feet(ft), inches(in) { cout<< "Two Arguments Constructor has been Called \n" ; }
31

Objects as Function Arguments (2/3)

void getdist(){ // get length from user cout << "\nEnter feet: "; cin >> feet; cout << "Enter inches: "; cin >> inches; } void showdist(){ // display distance cout << feet << "\'-" << inches << '\"'; } void add_dist( Distance, Distance ); // declaration }; // member function is defined outside the class void Distance::add_dist(Distance d2, Distance d3){ inches = d2.inches + d3.inches; // add the inches feet = 0; // (for possible carry) if(inches >= 12.0){ // if total exceeds 12.0, inches -= 12.0; // then decrease inches by 12.0 feet++; // and increase feet by 1 }

32

Objects as Function Arguments (3/3)

feet += d2.feet + d3.feet; // add the feet } int main(){ Distance dist1, dist3; // Calls no Distance dist2(11, 6.25); // Calls two dist1.getdist(); // get dist1 dist3.add_dist(dist1, dist2); // dist3 // display all lengths cout << "\ndist1 = "; dist1.showdist(); cout << "\ndist2 = "; dist2.showdist(); cout << "\ndist3 = "; dist3.showdist(); cout << endl; return 0; }
33

args. constructor args. constructor from user = dist1 + dist2

Constructors Overloading

Since there are now two explicit constructors with the same name, Distance(), we say the constructor is overloaded. Which of the two constructors is executed when an object is created depends on how many arguments are used in the definition: Distance length; // calls first constructor Distance width(11, 6.0); // calls second constructor

34

Member Functions Defined Outside the Class

void add_dist( Distance, Distance ); This tells the compiler that this function is a member of the class but that it will be defined outside the class declaration, someplace else in the listing.
35

Objects as Arguments

Since add_dist() is a member function of the Distance class, it can access the private data in any object of class Distance supplied to it as an argument, using names like dist1.inches and dist2.feet. In the following statement dist3.add_dist(dist1, dist2); add_dist() can access dist3, the object for which it was called, it can also access dist1 and dist2, because they are supplied as arguments. When the variables feet and inches are referred to within this function, they refer to dist3.feet and dist3.inches. Notice that the result is not returned by the function. The return type of add_dist() is void.

36

Objects as Arguments

The result is stored automatically in the dist3 object. To summarize, every call to a member function is associated with a particular object (unless its a static function; well get to that later). Using the member names alone (feet and inches), the function has direct access to all the members, whether private or public, of that object. member functions also have indirect access, using the object name and the member name, connected with the dot operator (dist1.inches or dist2.feet) to other objects of the same class that are passed as arguments.
37

22 2.25

10 8

11 6.25

38

The Default Copy Constructor

Weve seen two ways to initialize objects.

A no-argument constructor can initialize data members to constant values A multi-argument constructor can initialize data members to values passed as arguments.

You can also initialize one object with another object of the same type. Surprisingly, you dont need to create a special constructor for this; one is already built into all classes. Its called the default copy constructor. Its a one argument constructor whose argument is an object of the same class as the constructor. The next program shows how this constructor is used.

39

The Default Copy Constructor

(1/2)

// ecopycon.cpp initialize objects using default copy constr. #include <iostream> using namespace std; class Distance{ // English Distance class private: int feet; float inches;

public: Distance() : feet(0), inches(0.0) // constructor (no args) { cout<< "No Arguments Constructor has been Called \n" ; } Distance(int ft, float in) : feet(ft), inches(in) { cout<< "Two Arguments Constructor has been Called \n" ; } void getdist(){ // get length from user cout << "\nEnter feet: "; cin >> feet; cout << "Enter inches: "; cin >> inches; }
40

The Default Copy Constructor

void showdist(){ //display distance cout << feet << "\'-" << inches << '\"'; }

(2/2)

}; int main(){ Distance dist1; // calls no arguments constructor Distance dist2(11, 6.25); // calls two-arg constructor Distance dist3(dist2); // calls default copy constructor Distance dist4 = dist2; // also calls default copy const. // display all lengths cout << "\ndist1 = "; dist1.showdist(); cout << "\ndist2 = "; dist2.showdist(); cout << "\ndist3 = "; dist3.showdist(); cout << "\ndist4 = "; dist4.showdist(); cout << endl; return 0; }
41

Returning Objects from Functions

(1/3)

// englret.cpp function returns value of type Distance #include <iostream> using namespace std; class Distance{ // English Distance class private: int feet; float inches; public: Distance() : feet(0), inches(0.0) // constructor (no args) { cout<< "No Arguments Constructor has been Called \n" ; } // constructor (two args) Distance(int ft, float in) : feet(ft), inches(in) { cout<< "Two Arguments Constructor has been Called \n" ; } void getdist(){ // get length from user cout << "Enter feet: "; cin >> feet; cout << "Enter inches: "; cin >> inches; }

42

Returning Objects from Functions

void showdist(){ //display distance cout << feet << "\'-" << inches << '\"'; } Distance add_dist(Distance); // add };

(2/3)

// add this distance to d2, return the sum Distance Distance::add_dist(Distance d2){ Distance temp; // temporary variable temp.inches = inches + d2.inches; // add the inches if(temp.inches >= 12.0){ // if total exceeds 12.0, temp.inches -= 12.0; // then decrease inches by 12.0 and temp.feet = 1; // increase feet by 1 } temp.feet += feet + d2.feet; // add the feet return temp; } 43

Returning Objects from Functions

int main() { Distance dist1, dist3; Distance dist2(11, 6.25); dist1.getdist(); dist3 = dist1.add_dist(dist2); // // // //

(3/3)

define two lengths define, initialize dist2 get dist1 from user dist3 = dist1 + dist2

// display all lengths cout << "\ndist1 = " ; dist1.showdist(); cout << "\ndist2 = " ; dist2.showdist(); cout << "\ndist3 = " ; dist3.showdist(); cout << endl; return 0;
}

44

Returning Objects from Functions

To execute the statement dist3 = dist1.add_dist(dist2); A temporary object of class Distance is created to store the sum. The sum is calculated by adding two distances.

The first is the object dist1, of which add_dist() is a member. Its

member data is accessed in the function as feet and inches. The second is the object passed as an argument, dist2. Its member data is accessed as d2.feet and d2.inches. The result is stored in temp and accessed as temp.feet and temp.inches.
45

Returning Objects from Functions

The temp object is then returned by the function using the statement return temp; The statement in main() assigns it to dist3. Notice that dist1 is not modified; it simply supplies data to add_dist(). Figure 6.7 shows how this looks. In Chapter 8, Operator Overloading well see how to use the arithmetic + operator to achieve the even more natural expression dist3 = dist1 + dist2;

46

22 2.25

10 8

11 6.25
47

Structures and Classes

In fact, you can use structures in almost exactly the same way that you use classes. The only formal difference between class and struct is that in a class the members are private by default, while in a structure they are public by default. You can just as well write
class foo { int data1; public: void func(); }; //and the data1 will still be private.
48

Structures and Classes

If you want to use a structure to accomplish the same thing as this class, you can dispense with the keyword public, provided you put the public members before the private ones
struct foo{ void func(); private: int data1;

};

// since public is the default.

However, in most situations programmers dont use a struct this way. They use structures to group only data, and classes to group both data and functions.
49

Classes, Objects and Memory

you might have the impression that each object created from a class contains separate copies of that classs data and member functions. Its true that each object has its own separate data items But all the objects in a given class use the same member functions. The member functions are created and placed in memory only oncewhen they are defined in the class definition. Since the functions for each object are identical. The data items, however, will hold different values.
50

51

Static Class Data

If a data item in a class is declared as static, only one such item is created for the entire class, no matter how many objects there are. A static data item is useful when all objects of the same class must share a common item of information. A member variable defined as static has characteristics similar to a normal static variable: It is visible only within the class, but its lifetime is the entire program. It continues to exist even if there are no objects of the class. a normal static variable is used to retain information between calls to a function, static class member data is used to share information among the objects of a class.
52

Uses of Static Class Data

Why would you want to use static member data? As an example, suppose an object needed to know how many other objects of its class were in the program. In a road-racing game, for example, a race car might want to know how many other cars are still in the race. In this case a static variable Total_Cars could be included as a member of the class. All the objects would have access to this variable. It would be the same variable for all of them; they would all see the same number of Total_Cars.

53

Static Data Class

(1/2)

// statdata.cpp demonstrates a simple static data member #include <iostream> using namespace std; class Car{ private: static int Total_Cars; // only one data item for all objects // note: "declaration" only! public: Car() // increments count when object created { Total_Cars++; } int How_Many() // returns count { return Total_Cars; } ~Car() { Total_Cars--; } }; int Car::Total_Cars = 0; // *definition* of count
54

Static Data Class

(2/2)

int main() { Car Toyota, Honda, Suzuki; // create three objects cout << Toyota.How_Many() << " Cars are in Race" << endl; cout << Honda.How_Many() << " Cars are in Race" << endl; // each object sees the same data cout << Suzuki.How_Many() << " Cars are in Race" << endl; Car *Pajero = new Car; cout << Suzuki.How_Many() << " Cars are in Race" << endl; delete Pajero; cout << Honda.How_Many() << " Cars are in Race" << endl; return 0; }
55

Static Class Data (Separate Declaration and Definition)

Ordinary variables are usually declared (the compiler is told about their name and type) and defined (the compiler sets aside memory to hold the variable) in the same statement. e.g. int a; Static member data, on the other hand, requires two separate statements.

The variables declaration appears in the class definition, but the variable is actually defined outside the class, in much the same way as a global variable.

If static member data were defined inside the class, it would violate the idea that a class definition is only a blueprint and does not set aside any memory.
56

const Members Functions

A const member function guarantees that it will never modify any of its classs member data.

//constfu.cpp demonstrates const member functions class aClass { private: int alpha; public: void nonFunc() // non-const member function { alpha = 99; } // OK void conFunc() const { alpha = 99; }
};

// const member function // ERROR: cant modify a member

57

Distance Class and Use of const

(1/3)

// const member functions & const arguments to member functions #include <iostream> using namespace std; class Distance{ // English Distance class private: int feet; float inches; public: // constructor (no args) Distance() : feet(0), inches(0.0) { } // constructor (two args) Distance(int ft, float in) : feet(ft), inches(in) { } void getdist(){ // get length from user cout << "\nEnter feet: "; cin >> feet; cout << "Enter inches: "; cin >> inches; }
58

Distance Class and Use of const

void showdist() const // display distance { cout << feet << "\'-" << inches << '\"'; } Distance add_dist(const Distance&) const; //add

(2/3)

}; //add this distance to d2, return the sum Distance Distance::add_dist(const Distance& d2) const{ Distance temp; // temporary variable // feet = 0; // ERROR: cant modify this // d2.feet = 0; // ERROR: cant modify d2 temp.inches = inches + d2.inches; // add the inches if(temp.inches >= 12.0) // if total exceeds 12.0, { temp.inches -= 12.0; // then decrease inches by 12.0 temp.feet = 1; // and increase feet } // by 1 temp.feet += feet + d2.feet; // add the feet return temp; }

59

Distance Class and Use of const

int main() { Distance dist1, dist3; Distance dist2(11, 6.25); dist1.getdist(); dist3 = dist1.add_dist(dist2);

(3/3)

// // // //

define two lengths define, initialize dist2 get dist1 from user dist3 = dist1 + dist2

//display all lengths cout << "\ndist1 = "; dist1.showdist(); cout << "\ndist2 = "; dist2.showdist(); cout << "\ndist3 = "; dist3.showdist(); cout << endl; return 0;
}

60

const Member Function Arguments

if an argument is passed to an ordinary function by reference, and you dont want the function to modify it, the argument should be made const in the function declaration (and definition). This is true of member functions as well.
Distance Distance::add_dist(const Distance& d2) const{

In above line, argument to add_dist() is passed by reference, and we want to make sure that wont modify this variable, which is dist2 in main(). Therefore we make the argument d2 to add_dist() const in both declaration and definition.
61

const Objects

In several example programs, weve seen that we can apply const to variables of basic types such as int to keep them from being modified. In a similar way, we can apply const to objects of classes. When an object is declared as const, you cant modify it. It follows that you can use only const member functions with it, because theyre the only ones that guarantee not to modify it. e.g. A football field (for American-style football) is exactly 300 feet long. If we were to use the length of a football field in a program, it would make sense to make it const, because changing it would represent the end of the world for football fans.
62

const Objects

(1/2)

// constObj.cpp constant Distance objects #include <iostream> using namespace std; class Distance // English Distance class { private: int feet; float inches; public: // 2-arg constructor Distance(int ft, float in) : feet(ft), inches(in) { } void getdist() // user input; non-const func { cout << "\nEnter feet:" ; cin >> feet; cout << "Enter inches:" ; cin >> inches; }
63

const Objects

(2/2)

void showdist() const // display distance; const func { cout << feet << "\'-" << inches << '\"'; } }; int main() { const Distance football(300, 0); // football.getdist(); // ERROR: getdist() not const cout << "football = " ; football.showdist(); // OK cout << endl; return 0; }
64

Assignment Number 1
Create a class called time

Question 1

that has separate int member data for hours, minutes, and seconds. One constructor should initialize this data to 0, and another constructor should initialize it to fixed values. Make void print() to display time in 23:59:59 format. Make void setHour( int ) to set hours. Make void setminute (int ) to set minutes. Make void setSecond( int ) to set seconds. Make void setTime( int, int, int ) to set hour, minute, second

Make int getHour(); int getMinute(); int getSecond(); to return hours, minute and seconds respectively.
65

Assignment Number 1

Question 1

include a tick member function that increments the time stored in a Time object by one second. An add member function should add two objects of type time passed as arguments.
Incrementing into the next minute. Incrementing into the next hour. Incrementing into the next day (i.e., 23:59:59 to 00:00:00).

Be sure to test the following cases:

1.
2. 3.

Make 1000 times loop in a main function. Call tick and printTime functions in that loop for an object. Also make two objects and add them to a third object and print their values.
66

Assignment Number 1

Question 2

Create a class called date that has separate int member data for year, month, and day. One constructor should initialize this date to 20-02-2010, and another constructor should initialize it to fixed values given by user. Make void print() to display date in dd-mm-yyyy format. Make void setDate( int, int, int ) to set day, month, year perform error checking while setting the values for data members month, day and year. Make void nextDay() to increment the day by one. Be sure to test the following cases: Incrementing into the next month. Incrementing into the next year. in main() test function nextDay in a loop that prints the date during each iteration to illustrate that nexTDay works correctly.
67

Assignment Number 1

Question 3

Create a class called Rational for performing arithmetic with fractions. Write a program to test your class. Use integer variables to represent the private data of the class the numerator and the denominator. Provide a constructor that enables an object of this class to be initialized when it is declared. The constructor should contain default values in case no initializers are provided and should store the fraction in reduced form. For example, the fraction 2/4 would be stored in the object as 1 in the numerator and 2 in the denominator. Provide public member functions that perform each of the following tasks:
68

Assignment Number 1
1.

Question 3

2.

3.

4.

5.

6.

Adding two Rational numbers. The result should be stored in reduced form. Subtracting two Rational numbers. The result should be stored in reduced form. Multiplying two Rational numbers. The result should be stored in reduced form. Dividing two Rational numbers. The result should be stored in reduced form. Printing Rational numbers in the form a/b, where a is the numerator and b is the denominator. Printing Rational numbers in floating-point format.
69

Assignment Number 1

Question 4

Implement a Circle class. Each object of this class will represent a circle, storing its radius and the x and y coordinates of its center as floats. One constructor should initialize it data to 0, and another constructor should initialize it to fixed values given by user. Make void setValues(float, float, float) functions to set x,y and radius. Make float area() function, and a float circumference() function to return area and circumference. Make void print() function to display xy coordinates and radius of a circle. Call these functions in main() to display their working.
70