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
