Scribd
Upload
55 views49 pages

Review of C++ Programming: Sheng-Fang Huang

The document summarizes key concepts in C++ programming including composition, dynamic memory management, static class members, operator overloading, and copy constructors. Specifically, it discusses: 1) Composition allows a class to contain objects of other classes as members. For example, an AlarmClock class could have a Time class as a member. 2) Dynamic memory is allocated using new and deleted using delete. new calls a constructor and returns a pointer, while delete calls a destructor. 3) Static members are shared across all class instances rather than belonging to a specific object. They are declared with the static keyword.

Uploaded by

Ifat Nix
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PPT, PDF, TXT or read online on Scribd
55 views49 pages

Review of C++ Programming: Sheng-Fang Huang

The document summarizes key concepts in C++ programming including composition, dynamic memory management, static class members, operator overloading, and copy constructors. Specifically, it discusses: 1) Composition allows a class to contain objects of other classes as members. For example, an AlarmClock class could have a Time class as a member. 2) Dynamic memory is allocated using new and deleted using delete. new calls a constructor and returns a pointer, while delete calls a destructor. 3) Static members are shared across all class instances rather than belonging to a specific object. They are declared with the static keyword.

Uploaded by

Ifat Nix
Copyright
© © All Rights Reserved
We take content rights seriously. If you suspect this is your content, claim it here.
Available Formats
Download as PPT, PDF, TXT or read online on Scribd
You are on page 1/ 49

Review of C++ Programming

Part II
Sheng-Fang Huang

Composition: Objects as Members


of Classes
Composition
A class can have objects of other classes as
members
Example
AlarmClock object with a Time object as a member

A common form of software reusability is


composition, in which a class has objects of
other classes as members.

Composition: Objects as Members


of Classes
Initializing member objects
Member initializers pass arguments from the
objects constructor to member-object
constructors
If a member initializer is not provided
A compilation error occurs if the member objects
class does not provide any proper constructor.

Parameters to be passed via member


initializers to the constructor for class Date

const objects of class Date as members

Member initializers that pass arguments to


Dates implicit default copy constructor

Passing objects to a host object constructor

friend
To declare a function as a friend of a class:
Provide the function prototype in the class
definition preceded by keyword friend.

To declare a class as a friend of a class:


Place a declaration of the form
friend class ClassTwo;
in the definition of class ClassOne
All member functions of class ClassTwo are
friends of class ClassOne

friend Classes
Friendship is granted, not taken
For class B to be a friend of class A, class A must
explicitly declare that class B is its friend

Friendship relation is neither symmetric nor


transitive
If class A is a friend of class B, and class B is a
friend of class C, you cannot infer that class B is a
friend of class A, that class C is a friend of class B, or
that class A is a friend of class C

Place all friendship declarations first inside


the class definitions body and do not
precede them with any access specifier.

friend function declaration (can


appear anywhere in the class)

friend function can modify Counts private data

Calling a friend function; note that we


pass the Count object to the function

Dynamic Memory Management


with Operators new and delete
Dynamic memory management
Enables programmers to allocate and
deallocate memory for any built-in or userdefined type
Performed by operators new and delete
For example, dynamically allocating memory
for an array instead of using a fixed-size array

Dynamic Memory Management


with Operators new and delete
Operator new
Allocates (i.e., reserves) storage of the proper size for
an object at execution time
Calls a constructor to initialize the object
Returns a pointer of the type specified to the right of
new
Can be used to dynamically allocate any fundamental
type (such as int or double) or any class type

Heap
Region of memory assigned to each program for
storing objects created at execution time

Dynamic Memory Management


with Operators new and delete
Operator delete
Destroys a dynamically allocated object
Calls the destructor for the object
Deallocates (i.e., releases) memory from the
heap
The memory can then be reused by the
system to allocate other objects
Not releasing dynamically allocated memory when
it is no longer needed can cause the system to run
out of memory prematurely. This is sometimes
called a memory leak.

Dynamic Memory Management


with Operators new and delete
new operator can be used to allocate
arrays dynamically
Dynamically allocate a 10-element integer
array:
int *gradesArray = new int[ 10 ];
Size of a dynamically allocated array
Specified using any integral expression that can be
evaluated at execution time

Dynamic Memory Management


with Operators new and delete
Delete a dynamically allocated array:
delete [] gradesArray;
If the pointer points to an array of objects
First calls the destructor for every object in the
array
Then deallocates the memory

If the statement did not include the square


brackets ([]) and gradesArray pointed to
an array of objects
Only the first object in the array would have a
destructor call

static Class Members


static data member
Only one copy of a variable shared by all
objects of a class
Class-wide information
A property of the class shared by all instances, not
a property of a specific object of the class

Declaration begins with keyword static

static Class Members


static member function
Is a service of the class, not of a specific object of
the class

static applied to an item at file scope


That item becomes known only in that file
The static members of the class need to be
available from any client code that accesses the
file
So we cannot declare them static in the .cpp file
we declare them static only in the .h file.

static Class Members


Use static data members to save
storage when a single copy of the data
for all objects of a class will suffice.
A classs static data members and
static member functions exist and
can be used even if no objects of that
class have been instantiated.

Function prototype for static member function

static data member keeps track of number


of Employee objects that currently exist

static data member is defined and


initialized at file scope in the .cpp file

static member function can access


only static data, because the function
might be called when no objects exist

Non-static member function


(i.e., constructor) can modify the
classs static data members

Calling static member function using class


name and binary scope resolution operator

Dynamically creating Employees with new


Calling a static member function
through a pointer to an object of the class

Fundamentals of Operator
Overloading
Types for operator overloading
Built in (int, char) or user-defined (classes)
Can use existing operators with user-defined types
Cannot create new operators

Overloading operators
Create a function for the class
Operator overloading contributes to C++s
extensibilityone of the languages most
appealing attributes

Overloading Stream Insertion and


Stream Extraction Operators
<< and >> operators
Already overloaded to process each built-in type
Can also process a user-defined class
Overload using global, friend functions

Example program
Class PhoneNumber
Holds a telephone number

Print out formatted number automatically


(123) 456-7890

Notice function prototypes for overloaded operators


>> and << (must be global, friend functions)

Allows cout << phone; to be interpreted


as: operator<<(cout, phone);

Display formatted phone number

ignore skips specified number of


characters from input (1 by default)

Input each portion of


phone number separately

Testing overloaded >> and <<


operators to input and output a
PhoneNumber object

Overloading Unary Operators


Overloading unary operators
Can overload as non-static member
function with no arguments
Can overload as global function with one
argument
Argument must be class object or reference to
class object

Remember, static functions only access


static data

Overloading Unary Operators


Overload ! to test for empty string
If non-static member function, needs no
arguments
class String
{
public:
bool operator!() const;

};
!s becomes s.operator!()

If global function, needs one argument


bool operator!( const String & )
s! becomes operator!(s)

Overloading Binary Operators


Overloading binary operators
Non-static member function, one argument
Global function, two arguments
One argument must be class object or reference

Overloading Binary Operators


Overloading +=
If non-static member function, needs one argument
class String
{
public:
const String & operator+=( const String & );

};
y += z becomes y.operator+=( z )

If global function, needs two arguments


const String &operator+=( String &, const
String & );
y += z becomes operator+=( y, z )

Most operators overloaded as


member functions (except << and
>>, which must be global functions)

Prototype for copy constructor

!= operator simply returns opposite of ==


operator only need to define the == operator

Operators for accessing specific


elements of Array object

We must declare a new integer array so the


objects do not point to the same memory

Want to avoid self assignment


This would be dangerous if this
is the same Array as right

integers1[ 5 ] calls
integers1.operator[]( 5 )

Retrieve number of elements in Array

Use overloaded >> operator to input

Use overloaded << operator to output

Use overloaded != operator to test for inequality

Use copy constructor

Use overloaded = operator to assign

Use overloaded == operator to test for equality

Use overloaded [] operator to access


individual integers, with range-checking

You might also like