C++ Classes

1. C++ Classes • Compiling C++ programs • Input & output • Class definition • Member function definitions • Utility functions • Constructors • Destructors • Other member functions

2. C++ • C++ is an enhanced version of C • Object-oriented-programming capabilities • Other improvements on C features • Is a “superset” of C • Can compile C programs with C++ compiler • Development • Bjarne Stroustrupat Bell Labs in early 1980’s • From C & Simula-67 • Originally called “C with classes” • Later changed to “C++”

3. Compiling C++ Programs • For C++ files, end with “.cpp” • In UNIX, use “g++” compiler % g++ program.cpp % ./a.out or: % g++ program.cpp –o output % ./output

4. Makefile in C++ • Save following as “makefile” output: program.o <tab>g++ program.o -o output <blank line> program.o: program.cpp <tab>g++ -c program.cpp <blank line> • Type in “make” to run the makefile • % make • g++ -c program.cpp • g++ program.o -o output • % ./output

5. //A program that adds 2 integers (add.cpp) #include <iostream> using namespace std; int main(){ int int1 = 0; cout << "Enter an integer: "; cin >> int1; int int2 = 0; cout << "Enter another integer: "; cin >> int2; int sum = int1 + int2; cout<<int1<<"+"<<int2<<"="<<sum<<endl; return 0; }

6. Header Files & namespace #include <iostream> • Preprocessor directive • Input/output stream header file • List of standard library header files (p. 533) • For programmer-defined header files • #include “myHeaderFile.h” using namespace std; • Standard C++ library namespace (used to prevent overlapping names)

7. Output & Input cout << "Enter an integer: "; • Output values to the screen • Standard output stream (cout), or “see-out” • Stream insertion operator (<<), or “put to” cin >> int1; • Obtain a value from the keyboard • Standard input stream (cin), or “see-in” • Stream extraction operator (>>), or “get from”

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

9. 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 (variables) are created (instantiated) from the class • Regular variables (char, int, double, etc.) are instances of built-in data types

10. //Fraction class definition (ADT - abstract data type) class Fraction{ public://accessible anywhere in program //Constructor initializes each data member Fraction(){ num = 0; den = 1; } //Set a new Fraction value & check data void 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 print() const{ cout << num << " / " << den; } private: //accessible only to member functions intnum; //data member int den; //data member };//terminate class definition with a semicolon

11. 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

12. Constant (const) • Principle of least privilege • Users should be given no more privilege than necessary to perform a job • Good software engineering • Function definition void print() const{ cout<<num<<"/"<<den<<endl; } • Const member functions cannot modify the object’s data members (not allowed by compiler)

13. Driver Program // Driver program to test class Fraction void main(){ //instantiate object f1 of class Fraction Fraction f1; f1.print(); // 0/1 //set the data Fraction f2; f2.set( 13, -27); f2.print(); // -13/27 //attempt invalid data Fraction f3; f3.set( 99, 0); f3.print(); // 99/1 } //See complete program at fraction.cpp

14. Accessing Class Members /*Use accessor functions to change or access class member data (See access.cpp)*/ class Fraction { private: int num, den; public: Fraction(){num = 0; den = 1; } void print() const{cout << num << "/" << den;} void setNum(int n){num = n;} void setDen(int d){if(d==0)d=1; den = d;} int getNum(){return num;} int getDen(){return den;} };

15. Driver Program // Driver program to test class Fraction int main(){ //set & get the data Fraction f2; f2.setNum(13); f2.setDen(27); cout<<"f2's numerator is:"<<f2.getNum()<<endl; cout<<" f2's denominator is:"<<f2.getDen()<<endl; return 0; } //Fraction f2's numerator is: 13 //Fraction f2's denominator is: 27

16. Utility Functions • Not all member functions are public • Utility functions are private • Also called a “helper function” • Supports the operation of member functions • Not intended to be used by the clients of a class • Cannot use in the main() function

17. Utility Functions //See utility.cpp class Fraction { public: ... void set( int n = 0, int d = 1){ if(d==0) d = 1; if(d < 0) {d = -d; n = -n;} num = n; den = d; reduce(); } private: int num, den; void reduce(){...} };

18. Utility Functions //Finds GCD using Euclid's algorithm (utility.cpp) ... void 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 f3; f3.set(6, 4); f3.print(); // 3/2 }

19. Function Overloading • Functions have same name, different parameters #include <iostream> using namespace std; int square(int); double square(double); int main(){ cout<<"square = "<<square(3)<<endl; //square = 9 cout<<"square = "<<square(3.3)<<endl; //square = 10.89 return 0; } int square(int a){return a*a;} double square(double a){return a*a;} //See overload.cpp

20. 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 constructors to initialize data members in different ways • Data to be initialized is put in parenthesis to the right of the object’s name

21. //Example of 3 overloaded constructors class Fraction { int num, den; //default is "private:" public: Fraction(){ cout<<"constructor1"<<endl; num = 0; den = 1; } Fraction(int n) { cout<<"constructor2"<<endl; num = n; den = 1; } Fraction(int n, int d) {cout<<"constructor3"<<endl; num = n; den = d; } }; void main(){ Fraction f1, f2(2), f3(3,4); Fraction f[5] = {Fraction(), Fraction(6), Fraction(7,8)}; } • What is the output? • See constructors.cpp

22. Reference Variables • Used as an alias for other variables • It is an automatically dereferenced pointer //see ref.cpp #include <iostream> using namespace std; int main(){ int a = 7; int &b = a; /*put "&" in front of reference variable when declaring it*/ a++; cout<<"a="<<a<<" b="<<b<<endl; return 0; } //a=8 b=8

23. Reference Variables • Used in functions for call-by-reference #include <iostream> using namespace std; void square(int &); int main(){ int c = 2; cout<<"c="<<c<<endl; //c=2 square(c); cout<<"c="<<c<<endl; //c=4 return 0; } void square(int &d){ d = d * d; }

24. Copy Constructor • Called in three cases • When initializing an object in a program with parenthesis Fraction a; Fraction b(a); • When initializing an object in a program with the equals sign (Note: this is not the default assignment operator) Fraction a; Fraction b = a; • When passing-by-value to a function void foo(Fraction f){...}

25. 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 (such as linked list) • Example code: copy.cpp

26. 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 • Useful for dynamically allocated data members (such as linked list)

27. class Fraction { //What’s the output? int num, den; public: //constructor Fraction(int n) { num = n; den = 1; cout<<"Constructor ("<<num<<"/"<<den<<")"<<endl; } //destructor ~Fraction() { cout<<"Destructor ("<<num<<"/"<<den<<")"<<endl; } }; Fraction f1(10); int main(){ Fraction f2(20); { Fraction f3(30); static Fraction f4(40); { Fraction f5(50); } } return 0; } //See destructor.cpp

28. Other Member Functions • We can create any function that we wish for a class • For example, add(), subtract, multiply(), and divide() function for class Fraction • See math.cpp Fraction add(const Fraction &f){ int num3 = num * f.den + den * f.num; int den3 = den * f.den; Fraction f3(num3, den3); f3.reduce(); return f3; }

29. Passing Parameters • When passing a parameter to a method • Call-by-reference more efficient than call-by-value • Call-by-value creates a “local copy” of the variable with the “copy constructor” • Call-by-reference simple maintains a “place-holder”, as the actual changes are make to the variable in the calling routine • Not a big deal with simple data types (int, etc.) • Can be a big deal with user-defined data types (that contain a lot of data)

30. For Improved Efficiency • When possible, make parameters call-by-reference • Can speed up execution for some data types • If the data members should not be changed, use “const” reference parameters • Can help to prevent programming bugs • Principle of least privilege • A function should not be able to change a parameter if it is not necessary