Implementing Abstract Data Types (ADT) using Classes

Transcription

1 Implementing Abstract Data Types (ADT) using Classes Class Definition class classname { public: //public member functions private: //private data members and member functions }; // Note the semicolon! The class name becomes a new type name Keywords private, protected, public denote different level of access to the class members

2 Type of Class Members Non-static members that exist in every class object Static members exist independent of any class object, but are shared by all class objects. Use the modifier static to declare a member static Data members are variables that hold private data of a class object Member functions and operators are functions and (overloaded) operators that can be invoked for a class object

3 Access Control of Class Members The scope of the class is the block of its definition, plus the blocks of its member function definitions - Private' members can be accessed directly in the member functions and friend functions of the class - Public members can be accessed by any function/program through an object of the class object.funcname(argumentlist); - Protected members can only be accessed by derived classes - There can be as many private, public, and protected regions as one wishes - The default access mode is private - The compiler prevents unauthorized access to a class object's private and protected members

4 Class Members Functions Functions that just inspect (and do not modify ) the objects (inspectors) should be made constant members A constant member function cannot modify the object's state A constant member function is declared by returntype funcname(argumentlist) const; and is defined by returntype funcname(argumentlist) const { \\function code }

5 Class Members Functions Functions that update or modify the object are known as (mutators) - A class must provide sufficient operations for clients to modify the state of class objects - State update functions must ensure consistent states Functions not needed by clients but necessary for implementation of other functions should be declared private members

6 Function Overloading Two functions are overloaded if - they have the same name, - are declared in the same scope, and - have different parameter lists Use the same function name to define different functions Overloaded functions must be different in the number or types ( signature) of the formal parameters The compiler resolves each function call by a call to the most closely matched function definition based on the argument types Return type is not considered in overload resolution

7 Why Overload a Function Name? We may want to define a set of functions that perform the same general action but that apply to different types. Example 1: int imax(int, int); // find max of two ints int ivecmax(const vector<int>& v); //find the maximum //element in v int imatmax(const matrix<int>& m); //find the maximum //element in m Overload max int Max(int, int); // find max of two ints int Max(const vector<int>& v); //find the maximum //element in v int Max(const matrix<int>& m); //find the maximum //element in m Example 2 Overload class constructors

8 When not to Overload a function Name Whenever different function names provide information that would make the program easier to understand function name must not be overloaded Example: cursor movement on a computer screen a) move cursor to home position b) move cursor along x-direction relative to current position c) move cursor along y-direction relative to current position.

9 Default Arguments Allows programmer to define a default behavior Reduces need for similar functions that differ only in the number of parameters accepted Arguments to the call are resolved by position, and default arguments are used only to substitute the missing trailing arguments of a function call A parameter can have its default argument specified only once in a file By convention, the default argument is specified in the function declaration contained in the public header file

10 Default Arguments Example 1 //default.h int f1(int = 0); //default.cc #include default.h" int f1(int i = 0) {... } // error! since a default value // can be specified once in a file Example2 void PrintChar( char c = '= ', int n = 80) { } for (int i = 0; i < n; ++ i) cout << c; cout << endl;

11 Class constructors revisited Complex numbers are of the form z = x + yi, where x and y are real numbers - x is called the real part of z - y is called the imaginary part of z - i is sqrt(-1) Write a C++ class implementing complex numbers

12 Constructors for Complex Number Class // User code Complex a; // a = (0,0) = 0 Complex b(4, 0);// b = (4,0) = 4 Complex c(1,2); // c = (1,2) = 1+2i Complex d(c); // d = (1,2) = 1+2i [copy construction] First try class Complex{ }; public: Complex( ); Complex(double r); Complex(double r, double i); Complex(const Complex& c); // copy constructor // other member functions private: double re_; // real part double im_; // imaginary part

13 Complex Class Constructors Use default arguments and reduce the number of constructors needed Complex(double re=0.0, double im=0.0); Complex(const Complex& c); Implementation (in Complex.cc): complex::complex(double re, double im { } re_ = re; im_ = im; Complex::Complex(const Complex& c) { } re_ = c.re_; im_ = c.im_;

14 Methods for Input and Output // User code Complex z1; cout << "A complex number please, in the form (real, imag): "; z1.read(cin); //read the real and imaginary parts // other codes cout << z1 is: ; z1.write(cout); //Prototypes for the read and write methods class Complex{ public: // other member functions //Input and output methods void read( istream& is); void write(ostream& os)const; // };

15 Input and Output Implementation void Complex::read(istream &is) { char c1, c2, c3; // for (, ) is >> c1 >> r >> c2 >> i >> c3; if (is.good()){ // reading went OK! re_ = r; im_ = i; } } void Complex::write(ostream &os)const { } os<<"("<< re_<<", "<<im_<<")");