Engineering problem solving with c an object based approach
1 / 29

Engineering Problem Solving With C++ An Object Based Approach - PowerPoint PPT Presentation

  • Uploaded on

Engineering Problem Solving With C++ An Object Based Approach. Chapter 8 Introduction to Classes. Classes. The building blocks of object oriented programming Include function members and data members A well designed class is as easy to use as a pre-defined data type. Designing a Class.

I am the owner, or an agent authorized to act on behalf of the owner, of the copyrighted work described.
Download Presentation

PowerPoint Slideshow about 'Engineering Problem Solving With C++ An Object Based Approach' - tuari

An Image/Link below is provided (as is) to download presentation

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.

- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -
Presentation Transcript
Engineering problem solving with c an object based approach

Engineering Problem Solving With C++An Object Based Approach

Chapter 8

Introduction to Classes


  • The building blocks of object oriented programming

  • Include function members and data members

  • A well designed class is as easy to use as a pre-defined data type

Designing a class
Designing a Class

  • Desired operations

    • Member functions or methods

      • constructors

      • accessor functions

      • overloaded operators

      • ...

  • Required data members

Writing a class definition
Writing a Class Definition

  • A class definition has two parts

    • Class declaration

      • defines name of class, data members, and prototypes for member functions

    • Class implementation

      • implements the member functions

Class declaration
Class Declaration

  • Name of the class is specified using the key word class

  • Body of the class declaration includes

    • declaration statements for the data members

    • function prototypes

  • Keywords public, private and protectedspecify the accessibility of the class members

Example date class declaration
Example - Date Class Declaration

#include <iostream>

using namespace std;

class Date

{ //class body


void input(istream&); // I/O methods

void print(ostream&) const;

void setDate(int mo, int d, int y);

int get_day() const; // access methods

int get_month() const;

int get_year() const;


int day, month, year;


Date class
Date Class

  • Name of the class is Date

  • Three private data members

  • Six public function members

  • Data members can only be accessed by the member functions

Class implementation
Class Implementation

  • Includes

    • Function definitions for all function members

    • Scope Resolution Operator (::) specifies a function as a member of a class

Implementation of date class
Implementation of Date Class

#include “Date.h”

void Date::input(istream& in)

{ in >> month >> day >> year;


void Date::print(ostream& out) const;

{ out << month <<‘/’ <<day << ‘/’ << year;


void Date::set_date(int m, int d, int y)

{ month = m;

day = d;

year = y;


Accessor functions
Accessor Functions

  • Required to access private data members

  • Complete set should be provided

  • Our Date class requires 3 accessor functions

int get_day() const;

int get_month() const;

int get_year() const;

  • const should be placed at the end of any function that is not intended to modify the calling object.

Initializing objects
Initializing Objects

  • Constructorfunctions are used to initialize objects at the time they are declared

    • Called automatically

    • Same name as the class name

    • No return value, not even void

Constructors for the date class
Constructors for the Date Class

  • Default Constructor

    • constructor with no parameters

    • Prototype:


  • Constructor with Parameters

    • Prototype:

      Date(int m, int d, int y);

Default constructor
Default Constructor

  • Definition:

    Date::Date() : month(1), day(1), year(2002)

    { }

  • or


    { month = 1;

    day = 1;

    year = 2000;


  • First definition is preferred.

Constructors with parameters
Constructors With Parameters

  • Definition

    Date::Date(int m, int d, int y):month(m), day(d), year(y)

    { }

  • or

    Date::Date(int m, int d, int y)

    { month = m;

    day = d;

    year = y;


Using programmer defined classes
Using Programmer Defined Classes

  • Separate Compilation

    • Class declaration is saved in a file named classname.h

    • Class implementation is saved in a file named classname.cpp(or whatever extension your compiler expects)

    • .h file is included in user program and implementation file

    • User program is linked to implementation file

Using the date class
Using the Date Class

#include “Date.h”

int main()

{ Date today(4,6,2002), birthday;

//member functions are called using the dot operator




if(today.get_day() == birthday.get_day() &&

today.get_month() == birthday.get_month() )

cout << “happy birthday!”


Given this definition of a class for a rational number implement the default constructor, parameterized constructor, and the input function.

class rational

{ private:

int num, denom;


rational( ); // initialize to 1/1

rational(int n, int d);

void input (istream & istr ) const;

void output (ostream & ostr); // write as num/denom

bool improper() const; // true if num >= denom


Answer to practice
Answer to practice!

#include "rational.h"

rational::rational( ):num(1),denom(1)



rational::rational(int n, int d):num(n),denom(d)



void rational::input (istream & istr )


istr >> num >> denom;



  • Assignment operator is defined for objects of the same type

    Date d1, d2;


    d2 = d1;

  • Other operators are not predefined, but can be overloaded in the class definition(see chapter 10)

    • arithmetic, relational, logical, input and output

Helper functions
Helper Functions

  • Member functions

  • Called by other member functions

  • Usually specified as private


  • Design a class to implement a unit vector. A vector object will be represented by an anchor point (the base of the arrow), and an orientation(always between 0 and 360 degrees).  There are 2 manipulations that you can perform on a vector without changing its length.

    • translate (slide) the vector in the plane, changing its position but not its orientation.

    • rotate a vector, changing its orientation

Class declaration1
Class Declaration

class UnitVector { public:

UnitVector(); // contstructors

UnitVector(double init_x, double init_y, double init_orientation); void rotate(double d_orient);     // rotate the vector void translate(double dx, double dy); // translate the // vector.


//helper function     void fix_orientation();   // Calculate a legal orientation      double x, y;                   // The anchor point of the object.      int orientation; //orientation


Class implementation1
Class Implementation

//Constructor functions

UnitVector::UnitVector(double initial_x, double initial_y, double initial_orientation) : x(initial_x), y(initial_y), orientation(initial_orientation)




UnitVector::UnitVector( ):

x(0), y(0), orientation = 0;

{ }

Member function definitions
Member Function Definitions

// rotate the calling vector

void UnitVector::rotate(double d_orient)      

{ orientation += d_orient;



// translate the calling vector

void UnitVector::translate(double dx, double dy)

{ x += dx;

y += dy;


Helper function definition
Helper Function Definition

//This function adjusts the orientation value

//Original orientation may be < 0 or >= 360)

//Adjusted orientation is 0<=orientation < 360.

void UnitVector::fix_orientation()


if(orientation < 0)

orientation = 360 + orientation%360;


orientation = orientation%360;


Passing objects to functions
Passing Objects To Functions

  • Objects may be passed either "by value" or "by reference"

  • Example:

bool UnitVector::ShareBasePoint(UnitVector v)const

( if (x == v.x && y == v.y)

return true;


return false;



Which of the statements on the right is valid within a main program which contains an include for this header file.

class rational

{ private:

int num, denom;

int LCD( );


rational( );

rational(int n, int d);

void input (istream & istr );

void output (ostream & ostr) const;

void reduce ( );


  • rational A;

  • rational B(5, 9);

  • input(A);

  • B.output(cout);

  • int div=B.LCD();

  • A.denom = 3;

  • B.reduce;