Function templates. An abstraction on a function space. A generic type.

Transcription

1 Function templates. An abstraction on a function space. A generic type. // function template #include <iostream> using namespace std; template <class T> T Maximum (T, T); main () int i=5, j=86, k; long l=15, m=3, n; k=maximum<int>(i,j); n=maximum<long>(l,m); cout << k << endl; cout << n << endl; template <class T> T Maximum (T a, T b) T result; result = (a>b)? a : b; return result; OUTPUT A class is an extended concept of data structure. Instead of holding only data, it can hold both data and functions.

2 #include <iostream> using namespace std; class Rectangle private: int myx; int myy; void set_values(int, int); int area (); int peripheri(); ; void Rectangle :: set_values(int a, int b) myx=a; myy=b; int Rectangle :: area() return myx*myy; int Rectangle :: peripheri() return 2*(myx+myy); main() Rectangle x; x.set_values(4,5); cout<<"its area: "<<x.area()<<endl; cout<<"its peripheri: "<<x.peripheri()<<endl;

3 Some observations. Public Private Protected Access specifier of a class Available to public Available to other members of same class or to friends Available as in Private and to members of derived classes Private is the default access level even if you don t specify it as such. Therefore, by default, everything is private unless precisely specified otherwise. Class is like a type. Here we described a new type called Rectangle which has two private data members myx and myy, and three member functions with public access: setvalue(int, int), area(), and peripheri(). Note the most important specifier with two colons :: specifying the scope of the member function. Using constructors and destructor for a class. A constructor constructs an instant of a class when it is called; a destructor destroys a specific class object when no longer needed.

4 Program with a more meaty class definition: class Rectangle private: int myx; int myy; Rectangle(int a, int b) myx=a; myy=b; //a constructor void print() const cout<<myx<<" "<<myy<<endl; Rectangle(const Rectangle&); //a copy constructor int area (); int peripheri(); ; Rectangle :: Rectangle(const Rectangle& r) : myx(r.myx), myy(r.myy) The main routine tries out the code in this fashion: main() Rectangle x(53,41),y(16,48); // construct x and y x.print(); y.print(); cout<<"y area: "<<y.area()<<endl; cout<<"y peripheri: "<<y.peripheri()<<endl; y=x; //copy object x to y y.print(); OUTPUT

5 y area: 768 y peripheri: Friends of a class. Jerry Seinfeld in apt 5B has three friends: Kramer, George and Elaine in the sitcom Seinfeld. All his friends could barge in whenever they feel like. Kramer drops in mostly unannounced and goes for the fridge.. Therefore, Kramer is a friend of the object apt 5B which he doesn t own, but New class definition with sstream. This is just the interface for the class, we call it ADT (Abstract Data Type) for class Rectangle. ADT of a class Interface for the class Class definition without implementation.

6 #include <iostream> #include <sstream> using namespace std; class Rectangle friend Rectangle operator + (Rectangle, Rectangle); friend istream& operator >> (istream&, Rectangle&); friend ostream& operator << (ostream&, const Rectangle&); private: int myx; int myy; Rectangle(int a, int b) myx=a; myy=b; Rectangle(const Rectangle&); //a copy constructor int area (); int peripheri(); ; The implementation part of our class follows next. istream& operator >> (istream& in, Rectangle& r) in >> r.myx; in >> r.myy; return in; ostream& operator<<(ostream& out, const Rectangle& r) out << r.myx <<" "<<r.myy << endl; return out; Rectangle :: Rectangle(const Rectangle& r) : myx(r.myx), myy(r.myy)

7 int Rectangle :: area() return myx*myy; int Rectangle :: peripheri() return 2*(myx+myy); // The test-program is outlined below. main() Rectangle x(53,41),y(16,48); cout<<x<<"\n"; cout<<y<<"\n"; cin>>x; cout<<x<<endl; cout<<y<<endl; cout<<"y area: "<<y.area()<<endl; cout<<"y peripheri: "<<y.peripheri()<<endl; OUTPUT y area: 768 y peripheri:

8 Another way of using a friendly class. #include <iostream> using namespace std; class Square; class Rectangle private: int mywidth; int myheight; Rectangle (int a, int b) : mywidth(a), myheight(b) void print(); int area () return (mywidth * myheight); void convert (Square a); ; class Square private: int myside; Square(int a) : myside(a) friend class Rectangle; ; void Rectangle :: print() cout<<mywidth<<" "<<myheight<<endl; void Rectangle::convert (Square a) mywidth = a.myside; myheight = a.myside; //test program main ()

9 Square sqr(25); Rectangle rect(16,12); rect.print(); rect.convert(sqr); cout <<rect.area()<<endl; OUTPUT Another example. This time we define a Point class. And after it is successfully defined, we d use a Line class that might join two points. Point ss Line #include <iostream> #include <sstream> using namespace std; class Point friend ostream& operator << (ostream&, const Point&); protected: double myx; double myy; Point(double x=0.0, double y=0.0) : myx(x), myy(y) Point(const Point& p) : myx(p.myx), myy(p.myy) ~Point() Point& operator = (const Point& p) myx=p.myx;

10 ; myy=p.myy; return *this; double x() const return myx; double y() const return myy; string tostring() const ostringstream o; o<<"("<<myx<<","<<myy<<")"; return o.str(); ostream& operator << (ostream& out, const Point& p) return out << p.tostring(); main() Point p0; Point p1(2.3, -4.6); Point p2(5.89, 12.32); cout<<"p0: "<<p0<<" "<<"p1: "<<p1<<" "<<"p2: "<<p2<<endl; OUTPUT p0: (0,0) p1: (2.3,-4.6) p2: (5.89,12.32) An important feature in C++ class concept is inheritance. A derived class from a parent class inherits the parent class.

11 polygon Triangle Rectangle Both Rectangle and Triangle inherit the properties of the base class Polygon. To derive a class from the parent class, we express it as class Derived_class_name : public base_class_name. // An example of inheritance #include <iostream> using namespace std; class Polygon protected: int mywidth, myheight; void set_values(int a, int b) mywidth=a; myheight=b; ;

12 class Rectangle: public Polygon int area () return (mywidth * myheight); ; class Triangle: public Polygon int area () return (mywidth * myheight / 2); ; main () Rectangle rect; Triangle trgl; rect.set_values(8,6); trgl.set_values(12,13); cout << rect.area() << endl; cout << trgl.area() << endl; The members inherited by Rectangle and Triangle have the same access permission as they had in their base_class Polygon: Polygon :: mywidth protected access Triangle :: mywidth protected access Rectangle :: mywidth protected access Polygon :: set_values public access Triangle :: set_values public access When we declare class Triangle : public Polygon we are saying that the keyword public following the : mark

13 implies the maximum access level for all the members inherited from the parent class. This means that the derived class members will inherit all the members with the same access levels they had in the base class. e.g. class Daughter : protected Mother; implies all the members of the Daughter inherited from Mother would be set protected even if they were public in Mother. Note that protected access specifier is similar to private. However, when a class inherits from another one, the members of the derived class can access the protected members inherited from the base class, but not its private members. Access public protected private Members of the same class yes yes yes Members of derived class yes yes no Nonmembers yes no no An inheritance adds more meat to an ADT. class Cardiologist : public Doctor ; Here we intend to claim

14 Cardiologist is "a kind of a" Doctor Cardiologist is "derived from" Doctor Cardiologist is "a specialized" Doctor Cardiologist is a "subclass" of Doctor Cardiologist is a "derived class" of Doctor Doctor is the "base class" of Cardiologist Doctor is the "superclass" of Cardiologist Pointer of a derived class could be converted to a base class but not the other way round. If I m pointing at a cardiologist, I m pointing at a doctor. Therefore, this is ok. void f(doctor* d); void g(cardiologist* c) f(c); Derived classes do not get access to private members of a base class. This effectively "seals off" the derived class from any changes made to the private members of the base class. Multiple inheritance. A class could inherit from two or more classes. The following shows an example. #include <iostream> using namespace std; class Polygon protected: int width, height; void set_values (int a, int b) width=a; height=b; ;

15 class Output void otput (int i); ; void Output::otput (int i) cout << i << endl; class Rectangle: public Polygon, public Output int area () return (width * height); ; class Triangle: public Polygon, public Output int area () return (width * height / 2); ; main () Rectangle rect; Triangle trgl; rect.set_values (4,5); trgl.set_values (4,5); rect.otput (rect.area()); trgl.otput (trgl.area()); Some examples of ADT 1. ADT: Stack Representation: A container that contains items of same type.

16 Access: Access of a stack is only at one end, called the top of the stack. Removal must be made at the top. Constructors and destructor: create an empty stack of a given size destroy de-allocates the memory stack using Access functions: top returns the last element on the stack is_empty returns true if stack empty Mutator functions: push pop Inserts a new element at the top deletes the top element from the stack. top stack An Interface (ADT) for stack class: class Stack Stack(int s=100); //sets a default maximum for stack ~Stack(); //destructor for stack int top() const;

17 bool is_empty() const; bool is_full() const; void push(cosnt int); int pop(); ; private: int mya[]; // an array of integers int mymax; // maximum size of the stack int mycount; //number of elements in the stack 2. ADT: Queue Representation: A container that contains items of same type. Access: Access of a queue is only at front and at back. Insertions only at the back, deletions are from the front. Constructors and destructor: create an empty queue of a given size destroy de-allocates the memory queue using Access functions: back returns the last element in the queue front returns the first element of queue is_empty returns true if empty is_full returns true if full Mutator functions: insert Inserts a new element at the back delete deletes the element from the front.

18 back front entering leaving Queue An interface (ADT) for queue class class Queue Queue(int m=100); //create an 100 element queue ~Queue(); //Destructor int front const; // returns the front element int back const; //returns the element at the back bool is_empty() const; bool is_full() const; void enter(const int); int leave(); ; private: int mymax; // max number of items on the queue int mya[mymax]; // Queue itself int myfront; // location of next leave int myback; //location for next entry 3. ADT: Purse

19 Again, another container but more like a set rather than lists like stacks and queues. Contains pennies (1c), nickels (5c), dimes (10c) and quarters (25c) We go straight to the interface to present its ADT. class Purse private: int myp; int myn; int myd; int myq; //number of pennies in the purse //number of nickels in the purse //number of dimes in the purse //number of quarters in the purse ; Purse(int, int, int, int); //constructor ~Purse(); //destructor int pennies () const; // get pennies inr nickels () const; // get nickels int dimes () const; // get dimes int quarters () const; // get quarters int value() const; // return total value void reduce (); // reduce total value to dollars void insert(int); //insert into purse void remove(int); //remove from purse void empty(); // remove all from purse 4. ADT: Address We go straight to its interface to describe its ADT. class Address

20 ; private: string mystreet; string mycity; string mystate; string mycode; string mycountry; Address(string, string, string, string, string); string Street(); // returns mystreet string City(); // returns mycity string State(); //returns mystate string Code(); //returns mycode string Country(); // returns mycountry void set_street(string); // sets street void set_city(string); // sets city void set_state(string); // sets state void set_code(string); // sets code void set_country(string); // sets country 5. ADT: Ratio num A ratio is an object like,, is expressed as. 7 1 den class Ratio friend Ratio operator + (Ratio, Ratio); // allows adding two ratios friend Ratio operator * (Ratio, Ratio); // allows multiplication friend Ratio operator << (ostream&, const Ratio&); // print output freind Ratio operator >> (istream&, const Ratio&); //input operator protected: int mynum; // numerator

21 int myden; // denominator void reduce(); // reduce a ratio ; Ratio(int, int); //constructor Ratio(const Ratio&); // copy constructor void print() const; //print ratio void inverse() const; //inverse ratio and print