Location via proxy:   [ UP ]  
[Report a bug]   [Manage cookies]                
Scribd
Upload
14 views

02-Introduction To Classes and Objects

The document discusses defining classes in C++ including defining classes, creating objects, private members, separating class specification from implementation, and inline member functions. Key points covered include defining classes using the class keyword, creating objects from classes, using private and public access specifiers, defining member functions, and separating class declarations from definitions.

Uploaded by

Arif Istiaq
Copyright
© © All Rights Reserved
Available Formats
Download as PDF, TXT or read online on Scribd
14 views

02-Introduction To Classes and Objects

The document discusses defining classes in C++ including defining classes, creating objects, private members, separating class specification from implementation, and inline member functions. Key points covered include defining classes using the class keyword, creating objects from classes, using private and public access specifiers, defining member functions, and separating class declarations from definitions.

Uploaded by

Arif Istiaq
Copyright
© © All Rights Reserved
Available Formats
Download as PDF, TXT or read online on Scribd
You are on page 1/ 33

02: Introduction to Classes and

Objects

Programming Technique II
(SCSJ1023)

Adapted from Tony Gaddis and Barret Krupnow (2016), Starting out with
C++: From Control Structures through Objects
Content
 Defining classes

 Creating Object

 Private Members
- Why have private members ?
- Using private members function

 Separating Class Specification from Implementation

 Inline Member Functions


Defining Classes
Defining classes
 Classes are defined using keyword class, with the following
syntax:

 The declaration statements inside a class declaration are


for the variables/attributes and functions/methods that are
members of the class
Defining Class : Example
Defining Class : Access Specifiers

 Used to control access to members of the class

 public: can be accessed by functions outside of the class

 private: can only be called by or accessed by functions


that are members of the class
Defining Class
with Access Specifiers : Example
Private Members

Public Members
More on Access Specifiers

 Can be listed in any order in a class

 Can appear multiple times in a class

 If not specified, the default is private


Defining a Member Function
 When defining a member function:
 Put prototype in class declaration
 Define function/method using class name and scope resolution
operator (::)

Example
Using const With Member
Functions
 const appearing after the parentheses in a member
function declaration specifies that the function will not
change any data in the calling object.
Accessors and Mutators

 Mutator: a member function that stores a value in a private


member variable, or changes its value in some way

 Accessor: function that retrieves a value from a private


member variable. Accessors do not change an object's data,
so they should be marked const.
Creating Object
Creating Object

 An object is an instance of a class

 To define an object - defined like structure variables:

Rectangle r;

 Access members using dot operator:

r.setWidth(5.2);
cout << r.getWidth();

Compiler error if attempt to access private member using


dot operator
Example: Define Class and Object
Program 2-1

class
declaration
Example: Define Class and Object

Program 2-1 (Continued)


Program 2-1 (Continued)

objects
definition
Program 2-1 (Continued)
Private Members
Private Members

Why have private members ?

 Making data members private provides data


protection

 Data can be accessed only through public functions

 Public functions define the class’s public interface


Private Members : How to Access
Private Members?
 Code outside the class must use the class's public
member functions to interact with the object

Example
Separating Class Specification
from Implementation
Separating Class Specification from
Implementation
CONCEPT :

 Usually class declarations are stored in their own header files.


 Member function definitions are stored in their own .cpp files

 A header file that contains a class declaration is called a class


specification file.

 The name of the class specification file is usually the same as


the name of the class, with a .h extension
Separating Class Specification from
Implementation : example
 Place class declaration in a header file that serves as the
class specification file. Name the file ClassName.h, for
example, Rectangle.h

 Place member function definitions in ClassName.cpp,


(called implementation file) for example, Rectangle.cpp
File should #include the class specification file.

 Programs that use the class ,(called application file / driver


prog.) must #include the class specification file, and be
compiled and linked with the member function definitions.
Contents of Rectangle.h
This directive tells the
// Specification file for the Rectangle class. preprocessor to see if a
#ifndef RECTANGLE_H constant named
#define RECTANGLE_H RECTANGLE_H has not
been previously created
// Rectangle class declaration. with a #define directive
class Rectangle
{
private:
If the RECTANGLE_H
double width;
constant has not been
double length;
defined, these lines are
public:
included in the program.
void setWidth(double);
Otherwise, these lines are
void setLength(double);
not included in the
double getWidth() const;
program
double getLength() const;
double getArea() const;
};
#ifndef RECTANGLE_H The first included line defines the
#define RECTANGLE_H RECTANGLE_H constant. If this file
is included again, the include guard
class Rectangle will skip its contents
{
// Member declarations
// appear here.
};
#endif

Separating Class Specification tMyn 25


Contents of Rectangle.cpp
// Implementation file for the Rectangle class
#include “Rectangle.h”
#include <iostream> This directive includes the
#include <cstdlib> Rectangle.h file, which
contains the Rectangle class
using namespace std; declaration.

// setWidth definition
// setLength definition
// getWidth definition
// getLength definition
// getArea definition
Main Program File
(Contents of useRectangle.cpp)
// This program should be compiled with Rectangle.h file, Rectangle.cpp file
#include “Rectangle.h”
#include <iostream>

using namespace std;


int main()

{
Rectangle box; //Define an instance
double rectWidth; //Local variable
double rectLength; //Local variable
..
...

}
Separating Class Specification from
Implementation : Example
The implementation file Rectangle.cpp

The specification file Rectangle.h

The main program useRectangle.cpp

 Rectangle.obj and useRectangle.obj

Create an executable program ....


useRectangle.exe
Rectangle.h is Rectangle.h is
included in included in
Rectangle.cpp useRectangle.cpp

Rectangle.cpp Rectangle.h useRectangle.cpp


(Implementation (Specification File) (Main program
File) File)

Rectangle.cpp is compiled useRectangle.cpp is compiled


and useRectangle.obj is created and useRectangle.obj is created

Rectangle.obj and useRectangle.obj


are linked and useRectangle.exe is created useRectangle.obj
Rectangle.obj (Object file)
(Object file)

useRectangle. exe
(Executable file)

The process to create an executable program


Inline Member Functions
Inline Member Functions

Member functions can be defined


inline: in class declaration
after the class declaration

 Inline
 Data appropriate for short
can be accessed function
only throughbodies:
public functions

Example

int getWidth() const


{ return width; }
Rectangle Class with Inline Member
Functions
class Rectangle
{
private:
double width;
double length;
public:
void setWidth(double);
void setLength(double);
double getWidth() const
{ return width; }
double getLength() const 3 inline
{ return length; } member functions
double getArea() const
{ return width * length; }
};
Tradeoffs – Inline vs. Regular Member
Functions
 Regular functions – when called, compiler stores return
address of call, allocates memory for local variables, etc.

 Code for an inline function is copied into program in place


of call – larger executable program, but no function call
overhead, hence faster execution

You might also like