100 questions and answers about object-oriented programming (OOP) in C++, including definitions, solutions to problems, multiple possibilities and various code examples.
A very comprehensive introduction to the topic with very helpful basic examples on each aspect. Students will find this introduction very helpful as it walks them through the topic gradually from simple to moderate to advanced topics.
100 Q/A for OOP in C++
April 23, 2018
Object-Oriented Programming is a computer programming methodology/paradigm which is bio-inspired based on objects which constitute its fundamental building blocks as opposed to procedural programming which is based on procedures. OOP main elements: Encapsulation, Abstraction, Inheritance and Polymorphism. The elements of OOP will be explained in details and demonstrated in various parts of this tutorial.
The blueprint of an object, it defines (specification and implementation) object’s states and behaviors.
//---------------- Point.h ---------------
class Point{
private:
double x;
double y;
public:
void setX(double x);
void setY(double y);
double getX() const;
double getY() const;
};//--------------- Point.cpp ---------------
void Point::setX(double x){
this->x = x;
}
void Point::setY(double y){
this->y = y;
}
double Point::getX() const{
return x;
}
double Point::getY() const{
return y;
}An object is a single instance of a class; it is created by invoking the constructors of the class. Class exists in source temporal scope and objects exist in run-time temporal scope.
#include "Point.h"
int main(){
Point p0; // Point is the class, p0 is the object
return 0;
}In computing, abstraction means separating concepts from details through a hierarchy of layers. Examples:
The internal representation and implementation of an object is hidden from users. This concept encompasses: data abstraction, process abstraction and encapsulation.
A mechanism for code reuse and independent extension of the base class.
Example:
//---------------- Point3D.h ---------------
#include "Point.h"
class Point3D : Point{
private:
double z;
public:
void setZ(double z);
double getZ() const;
};//--------------- Point3D.cpp ---------------
void Point3D::setZ(double z){
this->z = z;
}
double Point3D::getZ() const{
return z;
}//--------------- main.cpp ---------------
#include "Point3D.h"
int main(){
Point3D p0;
P0.setX(1.1); // defined in base class
P0.setY(2.2); // defined in base class
P0.setZ(3.3); // extended in derived class
return 0;
}//---------------- Point3D.h ---------------
#include "Point.h"
class Point3D : Point{
private:
double z;
public:
void Point3D::setZ(double z){ // in-line function
this->z = z;
}
double getZ() const;
};//--------------- Point3D.cpp ---------------
double Point3D::getZ() const{
return z;
}void print(){ cout << “ X-coordinate = “ << x << endl << Y-coordinate = “ << y << endl; }void Point3D::randID(){
id = 1000 + rand() % (9000);
}class Point{
private:
protected:
double x;
double y;
int id;
double size;
void randID();
public:
};They all refer to the same thing, the means of modeling how the object can operate and behave. While data members model states and attributes, functions model actions, operations and behaviors.
The entire class body where every data member declarations, function members prototypes, constructors, accessors mutator prototypes and other elements of class declaration; all of these are typically kept in a header file “.h” apart from the implementation file of the class “.cpp”.
It is typically kept in a separate file apart from class specification. In the implementation file, all functions declared in the class specification section/file are defined including the constructors, destructor, accessors, mutators and other service functions.
class MyClass{ };//--------------- main.cpp ---------------
#include "Point3D.h"
int main(){
Point3D p0; // p0 is an instance of the class Point3D
p0.setX(0.0);
return 0;
}//--------------- main.cpp ---------------
#include "Point3D.h"
int main(){
Point3D p0; // instantiating the object p0 from the class Point3D
p0.setX(0.0); // using/communicating with the class
return 0;
}Objects interact with each other using messaging which is simply calling each other’s functions and receiving/causing the desired response.
They are special functions exits in the public section of the class used to instantiate and create new instances/objects of a class. The general characteristics of them include:
The system automatically provides:
A destructor is a special function member of a class designed to execute the required code when the object is about to be destroyed. One important task under destructors is the dynamic memory de-allocation.
Example: for constructors and the destructor:
//---------------- Point.h ---------------
class Point{
private:
double x;
double y;
int* connectedTo; // array of IDs keeps track of point ids connected to this.
const int MAX_CONN; // max num of points to be connected to this.
public:
Point(); // default constructor
Point(double, double, int*); // overloaded constructor
Point( Point& p ); // copy constructor
~Point(); // destructor
void setX(double x);
void setY(double y);
double getX() const;
double getY() const;
};//--------------- Point.cpp ---------------
void Point::setX(double x){
this->x = x;
}
void Point::setY(double y){
this->y = y;
}
double Point::getX() const{
return x;
}
double Point::getY() const{
return y;
}
Point::Point(){ // default constructor
MAX_CONN = 8;
x=0.0;
y=0.0;
connectedTo = new int[MAX_CONN];
}
Point::Point(double x, double y, int* p){ // overloaded constructor
MAX_CONN = 8;
this->x = x;
this->y = y;
connectedTo = new int[MAX_CONN];
for(int i=0; iSee (Q34).
//---------------- Point.h ---------------
class Point{
private:
public:
friend void reset(Point3D& p);
};//---------------------- main.cpp ---------------------------
void reset(Point3D& p){
p.x = 0; // private members accessed by a friend function
p.y = 0;
}//---------------- Point.h ---------------
#include "PHelper.h" // needed for the “friend” statement
class Point{
private:
public:
friend void PHelper::reset(Point& p);
};//--------------------------- PHelper.h ------------------------
class Point; // forward declaration if “Point” type is needed here
class PHelper{
private:
public:
void reset(Point& p);
};//------------------------ PHelper.cpp ----------------------
#include "Point.h"
// 1) required since the function reset accesses its members
// 2) "PHelper.h" is already included in "Point3D.h" no need to include it here
void PHelper::reset(Point& p){
p.x = 0;
p.y = 0;
}//---------------- Point.h ---------------
#include "PHelper.h" // needed for the “friend” statement
class Point{
private:
public:
friend class PHelper;
};//------------------ PHelper.h ------------------------
#include “Point.h”//------------------ PHelper.cpp --------------------
// All functions have access to private, protected and public sections of Point class.//---------------- Point.h ---------------
class Point{
private:
double x;
double y;
public:
virtual void print();
};//--------------- Point.cpp ---------------
void Point::print(){
cout << “ X = “ << x << “\t” << “ Y = “ << y << endl;
}//---------------- Point3D.h ---------------
#include "Point.h"
class Point3D : Point{
private:
double z;
public:
void print();
};//--------------- Point3D.cpp ---------------
void Point::print(){
cout << “ X = “ << x << “\t” << “ Y = “ << y << “\t” << “ Z = “ << z << endl;
}It occurs at compile time in function calls resolution in a hierarchy of inheritance if the functions members in base classes are not declared as “virtual”. See (Q40) if “virtual” key word is removed.
It occurs at run time in function calls resolution in a hierarchy of inheritance if the functions members in base classes are declared as “virtual”. See (Q40).
//--------------------------- main.cpp ----------------------
Point p1D;
Point3D p3D;
P3D = p1D; // object slicingSee (Q41 & Q42).
virtual void print() = 0;A Bat is both a mammal and a bird therefore, it inherits attributes and behaviors form both parents.
class Mammal {};
class Bird{};
class Bat : Mammal, Bird{};See (Q9 & 48).
See (Q48).
::It is a mechanism in OOP that facilitates the utilization of previously created code; its main advantages include: time saving, better resource utilization and reducing redundancy. One good example of code reuse is inheritance.
It means inheritance; where a derived class inherits all of the base class content and extends the data member or/and the function members. In OOP inheritance implies extension where, there is no point of just inheriting the same content of the base class and not adding any data or function members, if that is the case then, the base class by itself could be used directly and no need for inheritance.
#include "Point3D.h"
class Line3D{
private:
Point3D p1;
Point3D p2;
public:
Line3D(void);
~Line3D(void);
void setP1(Point3D& p);
void setP2(Point3D& p);
void print();
double length();
};//---------------- Point.h ---------------
class Point{
private:
public:
class NestedClass{
public:
NestedClass(){ cout << " Example on class nesting ...\n"; }
};
};//--------------------------- main.cpp -------------------
Point::NestedClass nc1;//--------------------- Point3D.cpp --------------------------
Point3D::Point3D(double x, double y, double z) : Point(x,y){
This->z = z;
}Two ways:
//------------------------ main.cpp --------------------------
void printObj(Point& p){
p.print();
}
int main(){
Point3D p0;
Point p1 = p0;
printObj( p1 ); // this will print the Point3D object
return 0;
}//-------------------------- main.cpp --------------------------
void printObj(Point* p){
p->print();
}
int main(){
Point* p0 = new Point3D();
printObj( p1 ); // this will print the Point3D object
return 0;
}NOTE: p0 is a pointer to Point but not a pointer to Point3D, so it ONLY can dereference members in Point but not those extended in derived classes. For example, the following statement is invalid: p0->setZ(1.2);
Let us implement an overloaded “-“ operator for the Point class we have. The “-“ operator for this class should mean the Euclidian distance between two points in 2D space and not simply subtracting two quantities.
//---------------------- Point.h ------------------------------
public:
double operator-(Point& p2);//-------------------- Point.cpp -----------------------------
double Point::operator-(Point& p2){
return sqrt( pow(x-p2.x,2) + pow(y-p2.y,2) );
}//------------------ main.cpp --------------------------------
Point p1(55.0, 33.0);
Point p2(22.0, 11.0);
cout << p1 – p2 << endl; // = 39.6611template
void tswap( T& obj1, T& obj2 ){
T temp = obj1;
obj1 = obj2;
obj2 = temp;
} //---------------------- main.cpp --------------------
int n1=99, n2=11;
tswap(n1, n2);
double d1=22.0, d2=33.0;
tswap(d1, d2);
Point p1(11.0, 99.0, new int[8]);
Point p2(22.0, 77.0, new int[8]);
tswap(p1, p2); // given that the “=” operator is defined in Point class.//------------------------- TArray.h --------------------------------
template
class TArray
{
private:
T * A;
int size;
public:
TArray(void);
TArray(int size);
~TArray(void);
T min();
};
template
void TArray::TArray(){
size = 1024;
A = new T[ size ];
for( int i=0; i
T TArray::min(){
T m = A[0];
for(int i=0; i double reciprocal(double x){
if(x==0)
throw std::overflow_error(" --- invalid operation --- ");
else
return 1/x;
}
int main(){
try{
cout << reciprocal(0);
}
catch(std::overflow_error e){
cout << e.what() << endl;
}
return 0;
}try{
// ...
}
catch( std::overflow_error e ){
// handle overflow
cout << e.what();
}
catch( std::bad_alloc e ){
// handle bad mem allocation
cout << e.what();
}
catch( std::bad_cast e ){
// handle bad dynamic cast
cout << e.what();
}
catch( ... ){
// handle default exception (the else case)
}//------------------- XArray.h ---------------------------
template
class XArray{
private:
T * A;
int size;
public:
XArray(void);
XArray(int size);
~XArray(void);
class IndexOutOfBound{
public:
void print(){ cout << "XArray::[] index out of bounds\n\n";}
}; }; //------------------------ main.cpp ----------------------
XArray myAD(16);
try{
cout << " A[-5] = " << setw(6) << myAD[-5] << endl;
}
catch(XArray::IndexOutOfBound e){
e.print();
} class LivingBeing{
};
class Animal : LivingBeing{
};
class Reptile : Animal{
};Abbildung in dieser Leseprobe nicht enthalten
class Point3D : public Point{
}Version 1: shallow copy
Point::Point( Point& p ){ // shallow copy constructor
x=p.x;
y=p.y;
connectedTo = p.connectedTo;
}Version 2: deep copy
Point::Point( Point& p ){ // DEEP copy constructor
x=p.x;
y=p.y;
connectedTo = new int[MAX_CONN];
for(int i=0; i// ---------------------- Point.h --------------------------
protected:
static int nObjs;// ------------------------- Point.h ------------------------
public:
static int getNobjs();// ------------------------- Point.cpp ---------------------
int Point::getNobjs(){
return nObjs;
}
Point::Point(){
id = 0;
size = 1;
x = -1;
y = -1;
z = -1;
nConnect = 8;
connectedTo = new int[nConnect];
++nObjs;
}//----------------------- main.cpp ---------------------------
Point p0;
cout << " NObjs = " << p0.getNobjs() << endl;
cout << " NObjs = " << Point3D::getNobjs() << endl;See (Q73).
// ---------------------- Point.cpp -------------------------
int Point3D::nObjs = 0;// --------------------------- Point.cpp -------------------
Point::Point(){
id = 0;
size = 1;
clr = BLACK;
x = -1;
y = -1;
z = -1;
nConnect = 8;
connectedTo = new int[nConnect];
++nObjs;
}//---------------------- Point.cpp --------------------------
void Point::computeDist(Point& p2){
dist = sqrt( pow(p2.x-x,2) + pow(p2.y-y,2));
}
double getDist(){
return dist;
}//---------------------- main.cpp --------------------------
Point p1(11, 22);
Point p2(55, 66);
p1.computeDist( p2 );
cout << p1.getDist(); // will print 62.2254
p1.setX(88);
cout << p1.getDist(); // will print 62.2254 à stale data//------------------------- main.cpp -------------------------
void printObj(Point p){
p.print();
}
void printObj(Point& p){
p.print();
}
void printObj(Point* p){
p->print();
}
int main(){
Point p1;
Point* pp = &p1;
printObj( p1 ); // works for the two functions val and &
printObj( pp ); // works for the pointer parameter function
}Point* p1 = new Point3D(); // works
Point3D* p2 = new Point(); // syntax error
Point p3 = *p2; // works
Point3D p4 = *p1; // syntax errorTClass myObj;// --------------------- main.pp -----------------------------
for(int i=0; i<100; ++i)
allocMem();Version 1: memory leakage
int allocMem(){
int* p = new int[100000000];
// process the array
// return result
}Version 2: memory safe
int allocMem(){
int* p = new int[100000000];
// process the array
// return results
delete [] p;
}//----------------------- main.cpp ----------------------
Point p1(11, 22);
Point p2, p3, p4;
p4 = p3 = p2 = p1;
// the copy(p2) call in this operator: is a private function
// that copies passed object to this object
Point3D Point3D::operator=(Point3D& p2){
copy(p2);
return *this;
}// ------------------------- main.cpp ---------------------
Point p1; // calls default constructor
Point* p2 = new Point(); // calls default constructorPoint p1(11, 22); // overloaded constructor is called
Point p2( p1 ); // copy constructor is calledSee (Q86)
// using static array of objects
Point p1, p2, p3;
Point pa1[3] = {p1, p2, p3};
// using dynamic array
Point* pa2 = new Point[3];
pa2[0] = p1;
pa2[1] = p2;
pa2[2] = p3;
for(int i=0; i<3; ++i){
cout << pa1[i].getX() << "\t";
cout << pa2[i].getY() << endl;
}// ------------------ Point3D.cpp -------------------
Point3D(double x, double y, double z){
Point::x = x;
Point::y = y;
This->z = z;
}// ---------------- main.cpp ----------------------
cout << Point::getNObj();See (Q67).
// ------------------- Point3D.cpp ------------------
void Point3D::print(){
Point::print();
cout << “ Z-coord = “ << z <// ----------------- main.cpp ----------------
Point3D readPoint(){
Point3D p;
cin >> p.x >> p.y >> p.z;
return p;
}// ------------- main() --------------------
Point3D p = readPoint();Point Point::getAcopy(){
return *this;
}Point* Point::getAptr(){
return this;
}// ---------- main.cpp ------------------
Point p1, p2, *p3;
p2 = p1.getAcopy();
p2.setX(99);
p3 = p1.getAptr();
p3->setX(99);See (Q94).
// ------------------ main.cpp ----------------
Point* createPointArray( int size, double x, double y ){
Point* pa = new Point[ size ];
for(int i=0; i// ---------------------- Class_B.h ------------------------
class Class_A;See (Q38).
Version 1: circular dependency
//--------------------- Class_A.h -------------------
class Class_A{
Class_B var_B;
}//--------------------- Class_B.h -------------------
class Class_B{
Class_A var_A;
}Version 2: circular dependency solved by forward declaration
//--------------------- Class_A.h -------------------
class B;
class Class_A{
Class_B var_B;
}//--------------------- Class_B.h -------------------
class A;
class Class_B{
Class_A var_A;
}#ifndef MY_HEADER_H
#define MY_HEADER_H
// my header file
#endifclass Base{
Base(){};
~Base(){};
}
class Derived{
Derived(){};
virtual ~Derived(){};
}
int main(){
Base* p = new derived();
Delete p;
}Object-Oriented Programming is a computer programming methodology based on objects as fundamental building blocks, emphasizing encapsulation, abstraction, inheritance, and polymorphism.
A class is the blueprint of an object, defining its states (data members) and behaviors (member functions). It specifies both the interface and implementation.
By default, members of a class are private, while members of a struct are public. Inheritance also defaults to private for classes and public for structs.
An object is a single instance of a class, created by invoking the class's constructor. Classes exist in the source code, while objects exist during program runtime.
Abstraction is the process of separating concepts from details through a hierarchy of layers, simplifying complex systems.
Data abstraction involves creating a structure that defines a complex data type with legal operations, hiding the implementation details from the user.
Process abstraction separates the process signature from the detailed implementation, allowing users to focus on how to use the process rather than how it's implemented.
Encapsulation is a mechanism to package data and its operations inside a single structure, providing data protection by controlling data access.
Information hiding hides the internal representation and implementation of an object from users, encompassing data abstraction, process abstraction, and encapsulation.
Inheritance is a mechanism for code reuse and independent extension of base classes, allowing derived classes to inherit and modify behavior.
Polymorphism is a mechanism where a behavior can have different forms based on the called function of the derived class within a hierarchical inheritance structure. It requires virtual functions in the base class.
Accessors are public functions that provide read access to private data members, while mutators provide write access.
Inline functions are defined entirely within the class specification body or specified using the "inline" keyword. The compiler replaces calls with the function body, avoiding function call overhead.
A public interface is a set of public functions in a class that provide data accessibility (read/write) and other service functions.
Private functions are defined in the "private" section of a class, visible only to the class itself, often serving as helper functions for public functions.
Private members are visible only to the class itself. Protected members are visible to the class and its derived classes. Public members are visible to all: class, derived classes, and the outside world.
These terms all refer to the data fields that provide data specification for a class.
These terms refer to the means of modeling how an object operates and behaves, modeling actions and operations.
Class specification is the entire class body, including data member declarations, function member prototypes, constructors, and other elements, typically kept in a header file (.h).
Class implementation is the definition of all functions declared in the class specification, including constructors, destructors, accessors, and other service functions, typically kept in a separate file (.cpp).
An instance of a class is an object created at runtime using a constructor. By setting its attributes, it becomes a specific object of the class.
Instantiation is the process of creating a new instance (object) of a class.
Objects interact using messages, which are function calls between objects.
Constructors are special public functions used to instantiate and create new objects of a class. They have the same name as the class and no return type.
The types include the Default constructor (no arguments), Overloaded constructor (with arguments), and Copy constructor (copies an existing object).
The system automatically provides a default constructor (uninitialized data) and a copy constructor (shallow copy).
No parameters, or all parameters have default values in its signature.
One or more parameters in its signature.
Only one parameter in its signature, which must be of its class type and passed by reference.
Destructors are special member functions executed when an object is about to be destroyed, often used for dynamic memory deallocation.
Yes, they can, but the "this->" pointer must be used to access the class data members.
All these terms refer to a class that extends and reuses a previously designed (base) class.
These terms refer to the class that is being extended or reused by other classes.
The "friend" modifier grants public access privilege to an entire other class or an external function defined outside the class.
A private constant pointer that points to the current instance of a class, accessible only by the class itself.
The "friend" keyword is used within the first class to grant access to a specific member of the other class.
Class A grants Class B access to all its content (private, protected, public) by declaring it as a friend.
They are a mechanism for dynamic function call binding in hierarchical inheritance (polymorphism). Used when a base class function needs to be overridden in a derived class.
Static binding occurs at compile time in function call resolution if functions in base classes are not declared as "virtual."
Dynamic binding occurs at runtime in function call resolution if functions in base classes are declared as "virtual."
It occurs when an instance of a child class is assigned to an instance of a parent class, potentially losing extra data members in the process.
Overloading: multiple functions with the same name but different parameters. Redefinition: non-virtual function in a derived class, statically bound. Overriding: virtual function redefined in a derived class, dynamically bound.
Early binding: static binding (compile time). Late binding: dynamic binding (runtime).
A mechanism that mandates all functions defined this way in the base class to be overridden in the derived class using "= 0" in the base class declaration.
A class that can only be derived from but cannot be instantiated. Defines at least one pure virtual function.
A derived class extends/inherits from multiple base classes, inheriting functionality from each.
Using the ":" symbol after the derived class name, followed by the access specifier (public, protected, private) and the base class name.
Derived class redefines the multiply-defined function, or invokes it in a particular base class using scope resolution operator (::).
Mechanism in OOP that utilizes previously created code, improving time efficiency and reducing redundancy. Inheritance is an example of code reuse.
Inheritance, where a derived class inherits all of the base class content and extends data members or function members.
Utilizing (by instantiation) one or more classes within another class to model a more complex object.
Declaring and defining an inner class within another.
Constructor: parent is called first, then child. Destructor: child is called first, then parent.
Parent's overloaded constructor is not automatically called.
In the child's overloaded constructor, use ":" and call the parent's overloaded constructor with the appropriate parameters.
Using reference variables or pointer variables, enabling dynamic binding.
Providing specific implementations for operators to operate on user-defined data types (UDT). Language-defined intrinsic data types like "int" have language-defined operators like +, -, *.
C++ feature that enables functions to process any data type (intrinsic or UDT) provided that all used operators are defined for this data type.
Extends function templates to classes, where the entire class is generic and handles any data type where all operators are defined for this data type.
Mechanism that manages run-time errors, separating error-handling code from the original code for better safety, readability, and maintainability.
"throw" is used to raise an exception within a function, interrupting normal execution and transferring control to a catch block.
By using multiple "catch" blocks for the same "try" block, each handling a specific exception type.
"try" blocks enclose code that might throw an exception, and "catch" blocks immediately follow to handle specific exceptions.
When standard exception types are insufficient, programmers create custom exception classes to manage specific error conditions.
Inheritance structure where multiple classes derive from one base class and derived classes can have further derived classes.
Base class access specifier (public, protected, private) that gives different privileges to derived classes.
Shallow copy: member-wise assignment, suitable when all members are statically defined. Deep copy: allocates new memory for dynamically allocated data in the copy constructor.
Data members defined with the "static" keyword that belong to the class itself, not to individual objects.
Function members defined with the "static" keyword that belong to the class itself, accessible without an object instance.
Using the object and the scope resolution operator or calling the static function directly using object.
Using the class name and the scope resolution operator (::), or from a static function.
They are static data members.
They are all other non-static data members.
Outside the class specification body, typically in the implementation file, or within the class specification body if they are constant ("static const").
In the implementations of the public interface functions (constructors) or any member function of the class.
Stale data is output data computed from old input data. To avoid, ensure computation uses the most recent input data, avoiding separate compute and get functions.
By value: creates a copy. By reference: passes the actual object without copying. As a pointer: passes the memory address of the object.
Recommended for functions that don't modify data members, placed after the function header to prevent accidental changes.
Allows behaviors to be dynamically bound, based on an inheritance hierarchy. A child class "is-a" parent class, meaning a derived object can be assigned to a base pointer/reference, but not vice versa.
All operators applied to objects of the classes in the function template must be supported by those classes.
Template classes need the specification and implementation sections in one file because the compiler needs to generate specific versions after instantiation.
When memory is dynamically allocated and not deallocated when no longer needed, eventually exhausting system resources.
Overloaded operators need to return the current object so that multiple instances of the same operator in one statement may work.
Declare an object of the class without initializing any parameters.
Create an object by passing an existing object of the same class to its constructor.
Use the operator with multiple assignment targets in one statement, e.g., a = b = c;
Declare a static array of objects and initialize it, or use dynamic memory allocation and initialize an array of objects using pointers.
Identifies which data/function members belong to which class and it allows a derived class to access base class members.
Using the scope resolution operator (::) followed by the function name.
Yes, by declaring the function to return an object of that class, with the object being constructed inside the function.
Yes, using the "this" keyword to return either a copy of the object (*this) or a pointer to the object (this).
Yes, using the "this" keyword to return a pointer to the object itself.
Yes, by dynamically allocating memory for the array and returning a pointer to the first element.
A declaration that informs the compiler about the existence of a class or function defined elsewhere. Example: class Class_A; inside another class.
Occurs when two classes include each other's header files, creating a dependency loop. Using forward declarations can break this dependency.
Using preprocessor directives such as #ifndef, #define, and #endif to guard the header file.
To ensure the correct destructor (derived class's destructor) is called when deleting a derived class object through a base class pointer, preventing memory leaks.
