1. C++ Classes & Data Abstraction
C & C++ differences
Class definition
Member function definitions
Makefiles
Utility functions
Constructors
Destructors

2. C & C++ Differences C: procedural programming language
Programming is action-oriented
Function is basic unit of programming

3. C & C++ Differences C++: object-oriented programming language
Programming is object-oriented
Class (a user-defined data type) is basic unit of programming
Attributes (data members)
Behaviors or operations (member functions)
Objects are created (instantiated) from the class
Variables are instances of built-in data types

4. Class Definition //Fraction abstract data type (ADT) definition
class Fraction{
public: //accessible anywhere in program
Fraction(); //member function prototype
void set(int, int); //member function prototype
void print(); //member function prototype
private: //accessible only to member functions
int num; //data member
int den; //data member
}; //terminate class definition with a semicolon

5. Member Access Specifiers
Public
Any data member or data function declared after this is accessible anywhere in the program
Private
Any data member or data function declared after this is only accessible to member functions of the class
If no specifiers are declared, then the default is private
Can list specifiers in any order
Protected
Used for inheritance

6. Member Function Definitions
//Constructor initializes each data member
Fraction::Fraction(){
num = 0;
den = 1; }
//Set a new Fraction value & check data
void Fraction::set(int n , int d ){
if(d == 0) d = 1;
if(d < 0) {d = -d; n = -n;}
num = n; den = d;
//Print a Fraction
void Fraction::print(){
cout << num << " / " << den;

7. Driver Program // Driver program to test class Fraction void main(){
//instantiate object t of class Fraction
Fraction t;
t.print(); // 0 / 1
//set the data
t.set( 13, -27);
t.print(); // -13 / 27
//attempt invalid data
t.set( 99, 0);
t.print(); // 99 / 1 }
(See complete program at fractionA.txt)

8. Accessing Class Members
class Fraction {
public:
Fraction();
void print();
int num, den; //Not good programming practice };
Fraction::Fraction() {num = 0; den = 1; }
void Fraction::print(){cout<<num<<"/"<<den<<endl;}
void main(){
Fraction t; //instantiate a fraction
Fraction *ptr = &t; //pointer to t
Fraction &ref = t; //reference to t
t.num = 1; t.den = 2; t.print(); // 1/2
ptr->num = 2; ptr->den = 3; ptr->print();// 2/3
ref.num = 3; ref.den = 4; ref.print(); // 3/4 }

9. Accessing Class Members
//Use accessor functions instead (accessor.txt):
class Fraction {
Private:
int num, den;
public:
Fraction();
void print();
void setNum(int);
void setDen(int);
int getNum();
int getDen(); };
void Fraction::setNum(int n){num = n;}
void Fraction::setDen(int d){if(d==0)d=1; den = d;}
int Fraction::getNum(){return num;}
int Fraction::getDen(){return den;}

10. Class Exercise
Write a member function for class Function that will multiply two fractions
Here is a sample driver program that uses this function:
void main(){
Fraction f1, f2;
f1.set(2,3);
f2.set(4,5);
f1.multiply(f2);
f1.print(); // 8/15
f2.print(); // 4/5 }

11. Multiple Files Header file (fraction.h)
Declaration of the Fraction class
To prevent multiple inclusions of header file:
#ifndef FRACTION_H
#define FRACTION_H
//header file code
#endif
Source-code file (fraction.cpp)
Member function definitions
At top of file: #include "fraction.h"
Driver program (driver.cpp)
Program that uses the Fraction class

12. Makefile Don’t forget to: (See makefile) To change “gcc” to “g++”
To change “.c” to “.cpp”
To tab the beginning of the 2nd line
To leave the 3rd line & last line with a newline
out: driver.o fraction.o
g++ driver.o fraction.o -o out
driver.o: driver.cpp fraction.h
g++ -c driver.cpp
fraction.o: fraction.cpp fraction.h
g++ -c fraction.cpp

13. Interface & Implementation
Separating interface from implementation
Good software engineering
Easier to modify a program
Changing the implementation will not change the driver program (as long as the interface stays the same)
Clients of a software do not need the to access the class source code, just need the object code & header file
For example, the driver program for class Fraction only needs fraction.h & fraction.o
See makefile

14. Utility Functions Not all member functions are public
Utility functions are private
Also called a helper function
Not part of a class interface
Supports the operation of member functions
Not intended to be used by the clients of a class

15. Utility Functions class Fraction { public: Fraction();
void set(int, int);
void print();
private:
void reduce();
int num, den; };
void Fraction::set( int n = 0, int d = 1){ if(d==0) d = 1;
num = n; den = d;
reduce(); }

16. Utility Functions //Finds GCD using Euclid's algorithm (utility.txt)
void Fraction::reduce(){
int a = num;
int b = den;
while (b!=0){
int temp = a % b;
a = b;
b = temp; }
num = num / a;
den = den / a;
void main(){
Fraction t;
t.set(6, 4);
t.print(); // 3/2

17. Constructors
A constructor is a class member function with the same name as its class
Used to initialize the class data members
Can have several overloaded to initialize data members in different ways
Data to be initialized is put in parenthesis to the right of the objects name
Constructors can also have default arguments

18. //Example of 3 overloaded constructors
class Fraction {
int num, den; //default is "private:"
public:
Fraction();
Fraction(int);
Fraction(int, int);
//Fraction(int = 0,int = 1);//default arguments };
Fraction::Fraction(){
cout<<"constructor1"<<endl;
num = 0; den = 1; }
Fraction::Fraction(int n) { cout<<"constructor2"<<endl;
num = n; den = 1; }
Fraction::Fraction(int n, int d) { cout<<"constructor3"<<endl;
num = n; den = d; }

19. Class Exercise
Using the previous slide’s constructors, what’s the output of this program?
void main(){
Fraction f1, f2(2), f3(3,4);
Fraction f[5] = {Fraction(), Fraction(6), Fraction(7,8)}; }
What would be the output, if only the constructor with default arguments was used?
See exercise2.txt

20. Copy Constructor Called in three cases
When declaring an object in a program
Fraction a;
Fraction b(a);
Fraction *c = new Fraction(b);
When declaring an object in a program (not the default assignment operator)
Fraction b = a;
When passing-by-value
void multiply(Fraction f)

21. Copy Constructor Can create your own copy constructor
Fraction(const Fraction &f){
num=f.num;
den=f.den; }
Otherwise the computer will create one for you
By default, performed by memberwise copy
Each data member of one object is copied to another object’s data members
Can cause problems with dynamically allocated data members

22. class Fraction { //What’s the output?
public:
Fraction(int n=0, int d = 1){
cout<<"constructor with default arguments"<<endl;}
Fraction(const Fraction &f){ cout<<"copy constructor"<<endl;} void foo(Fraction f){ Fraction g;} };
void main(){
Fraction f1(3,4);
Fraction f2(f1);
Fraction f3=f2;
f1.foo(f2); } (See exercise3.txt)

23. Destructors
A destructor is a class member function with the same name as its class with a tilde (~) character in front of it
Called when an object is “destroyed”
When program execution leaves the scope in which the object of that class was instantiated
For global objects & static objects, when the program ends execution
Performs termination housekeeping so memory can be returned to the system

24. class Fraction { //What’s the output?
int num, den;
public:
Fraction(int); //constructor
~Fraction(); //destructor };
Fraction::Fraction(int n) {
num = n; den = 1;
cout<<"Con., Fra. ="<<num<<"/"<<den<<endl; }
Fraction::~Fraction() {
cout<<"Des., Fra. = "<<num<<"/"<<den<<endl;
Fraction f1(10);
int main(){
Fraction f2(20); {
Fraction f2(30);
static Fraction f3(40);
Fraction f3(50);
} return 0;
} (See exercise4.txt)

25. Default Memberwise Copy
Assignment operator (=) can be used to assign one object to another
By default, performed by memberwise copy
Each data member of one object is copied to another object’s data members
Can cause problems with dynamically allocated data members
void main(){
Fraction f1, f2(3,4);
f1 = f2;
f1.print(); // 3/4
f2.print(); // 3/4 }

26. Default Memberwise Copy
If you were to write it yourself, it would look like this
Will talk more about this format in operator overloading
See complete program at copy.txt
const Fraction &operator=(const Fraction &f){
num=f.num;
den=f.den;
return *this; }