Object Oriented programming is based on three fundamental conpects:data abstraction,inheritance,and dynamic binding.

   the key idea behind OOP is polymorphism. in C++,ploymorphism applies only to references or

pointers to types related  by inheritance.

   Dynamic binding lets us write programs that use objects of any type in an inheritance hierarchy without caring about the object's specific types.Programs that use these classes need not distinguish

between functions defined in the base or in a derived class.

   Protected Members,an important property: Aderived object may access the protected members of its base class only through a derived object.The derived class has no spicial access to the protected membes of base type objects.

  example:

  void derived::memberFun(const derived &d,const base &b) { //assume that price is a protected member in base double ret = price; //ok,uses this->price ret = d.price; //ok,uses price from a derived object ret = b.price; //error,no access to price from an base //even thought price is a member of base }

Derived to Base Conversions

Because every derived object contains a base part,we can bind a base_type reference to the base-class part of a derived object. example:

//functions with a base reference parameter double print(const base&,size_t); base item; base *p = &item; //p points to a base object derived der; print(der,10); //passes reference to the base part of der p = &der; //p points to the base part of der.

Public,Private,and Protected Inheritance

   In Public inheritance,the members of the base retain their access levels.

   In Protected inheritance,the public and protected members of the base class are protected members

in the derived class.

   In private inheritance,all the members of the base are private in the derived class.

   All classes that inherit from base have the same access to the members in base,regardless of the access label in their derivation lists.the derivation access label controls the access that users of the derived class have to the members inherited from base.

a simple  example:

//Item sold at an undiscounted price //derived classes will define various discount strategies. class Item_base { public: Item_base(const std::string &book ="",double sales_price=0.0) : isbn(book),price(sales_price) {} std::string book() const { return isbn;} virtual double net_prices(std::size_t n) const { return n*price; } virtual ~Item_base() {} //purpose to enable dynamic binding by using virtual. public: //Cloning an unknown type //Handle classes often need to allocate a new copy of an existing object wihtout //knowing the precise type of the object virtual Item_base* clone() const { return new Item_base(*this);} private: std::string isbn;//accessible only to the members and friends of the base class protected: double price; //derived object can access but not for general users of the type. }; //discount kicks in when a specified unmber of copies of some book are sold //the discount is expressed as a fraction used to reduce the normal price class Bulk_item : public Item_base { public: double net_prices(std::size_t)const; private: std::size_t min_qty; double discount; //fractional discount to apply } double Bulk_item::net_prices(std::size_t cnt) const { if (cnt >= min_qty) return cnt*(1-discount)*price; //this->price else return cnt*price; }

   Friendship and Inheritance

Frineds may access the class'private and protected data.

Handle Classes and Inheritance

   The handle class stores and manages a pointer to the base class.the type of the object to which that pointer points will vary,it can point at either a base-or a derived-type object.

Defining the handle

   In addition to managing the use count,the Sales_item class will define the dereference and arrow operators:

class Sales_item { public: Sales_item() : p(0),use(new std::size_t(1)) {} //unbound handle //attaches a handle to a copy of the item_base object Sales_item(const Item_base&); //copy control members to manage the use count and pointers Sales_item(const Sales_item &i) : p(i.p),use(i.use) {++*use;} ~Sales_item() {decr_use();} Sales_item& operator= (const Sales_item&); //member access operators const Item_base* operator->() const { if (p) return p; else throw std::logic_error("unbound Sales_item"); } const Item_base& operator*() const { if (p) return p; else throw std::logic_error("unbound Sales_item"); } private: Item_base *p; //pointer to shared item std::size_t *use; //pointer to shared use count //called by both destructor and assignment operator to free pointers void decr_use() { if (--*use == 0) {delete p; delete use;} } }; Sales_item& Sales_item::operator=(const Sales_item &rhs) { //increment the use count of the right-hand operand and copied the pointer. ++*rhs.use; decr_use(); p = rhs.p; return *this; } //defining the handle constructors Sales_item::Sales_item(const Item_base &item) : p(item.clone()),use(new std::size_t(1)) {}

to be continue...