1 / 26

C++ Classes & Data Abstraction

C++ Classes & Data Abstraction. C & C++ differences Class definition Member function definitions Makefiles Utility functions Constructors Destructors. C & C++ Differences. C: procedural programming language Programming is action-oriented Function is basic unit of programming.

Download Presentation

C++ Classes & Data Abstraction

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript


  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 • At top of file: #include "fraction.h"

  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 a; 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; }

More Related