View
220
Download
0
Tags:
Embed Size (px)
Citation preview
Reusing Code
Private or Protected inheritance
A cool class for array
valarray class deals with numeric values, and it supports operation such as summing the contents and defining largest and smallest value.
valarray < int> q_values; // an array of int
valarray <double> weights;
……………………………………
double gpa[5]={3.1,3.5,3.8, 2.9, 3.3};valarray<double> v1;valarray<int>v2(8); // array of 8 intvalarray<int>v3(10,8); // array of 8 int each set to 10;valarray<double>v4(gpa,4); // 4 elements, 4 first values of gpa .
Private Inheritance
Private inheritance implements has-a relationship.
In private inheritance, public and protected members of the base class become private members of the derived class.
Methods of the base class can be used inside the member function of the derived class.
The public method of the base class becomes private method of derived class.
The derived class does not inherit the base-class interface.
class Student : private string, private valarray<double>
{
public :
….
}
By default inheritance is private. If we don’t use word private the inheritance is private.
If we derive a class from more than one class we have multiple inheritance.
How to initialize base-class component
Student( const char *str, const double *pd, int n) : string(str), ArrayDb(pd, n) { }
Accessing Base-Class methods
double Student :: Average( ) { if( ArrayDb ::size() > 0) return ArrayDb::sum() / ArrayDb::size(); else return 0;}
Accessing Base-Class Objects
const string & Student :: Name()
{
return (string &) *this;
}
// *this is the invoking of type Student
// here we type cast a Student object to a string object.
Accessing Base-Class Friend
ostream & operator << ( ostream &os , const Student & stu)
{
os << “Scores for “<<( string &) stu<<“ :\n”;
….
}
// Instead of *this we use the stu object.
In private inheritance, a reference or pointer to a base class can not assign a reference or pointer to a derived class
with out explicit type cast.
Even if we used public inheritance we would have to use explicit type cast.
os<<stu; //recursive call.
Protected Inheritance
A variation of private Inheritance
class Student : protected string, protected valarray<double>
{ ….};
The interface for the base class is available to the derived class but not to the outside world.
Difference between private and protected inheritance is :
With private inheritance the third generation class doesn’t get the internal use of the base class interface.
With protected inheritance public base class methods become protected in the second generation and are available internally to the next generation (third).
Note on constructors• Base class is always constructed first
• If no explicit arguments are passed to base class– Default constructor will be called
• Destructors are called in exactly the reverse order of the constructors.
Name Hiding
• If you redefine a member function in the derived class, all other overloaded functions in the base class are inaccessible.
Access protection• Members
– Public: visible to all clients– Protected: visible to classes derived from self
(and to friends)– Private: visible only to self and to friends!
• Inheritance– Public: class Derived : public Base ...– Protected: class Derived : protected Base ...– Private: class Derived : private Base ...
• default
How inheritance affects access
InheritanceType (B is)
public protected private
public A public in B protected in B hidden
private A private in B private in B hidden
protected A protected in B protected in B hidden
Suppose class B is derived from A. Then
Base class member access specifier
When is protected not protected?
• Protected is public to all derived classes
• For this reason– make member access functions protected– keep member variables private
Base ClassClient
Derived class
Overriding• Overriding redefines the body of a virtual
functionclass Base {public:
virtual void func();
}class Derived : public Base {public:
virtual void func(); //overrides Base::func()
}
Calls up the chain• You can still call the overridden function:
void
Derived::func() {
cout << "In Derived::func!";
Base::func(); // call to base class
}
• This is a common way to add new functionality• No need to copy the old stuff!
class Array{ private : int len; int *arr; public : Array (int ln=0); Array (const Array &rs); ~Array() {delete [ ] arr; } Array & operator= (const Array & rs); Array & operator+(const Array &rs); int Size( ) { return len;} int & operator[ ]( int i);}
int & Array::operator[ ]( int i){ if( i<0 || i>=n) { cout<<“error in array lim “<<“ out of rang
“<<endl; exit(1); } return arr[i];}
Array & Array::operator+(const Array &rs){ int i,t; if (len > rs.len) t=len; else t=rs.len; Array new_array(t); for(i=0;i<k;i++) new_array[i]=arr[i]+rs.arr[i]; for(i,i<len;i++) new_array[i]=arr[i]; for(i;i<rs.len;i++) new_array[i]=rs.arr[i]; return new_array; }
Array & Array::operator=(const Array &rs)
{
if (this == &rs )
return *this;
delete [ ] arr;
arr=new int[rs.len];
for(int i=0;i<len;i++)
arr[i]=rs.arr[i];
len=rs.len;
return *this;
}