Programming Languages and Design Lecture 5 Object-Oriented

							Programming Languages and
         Design

            Lecture 5
  Object-Oriented Programming

                                  Instructor: Li Ma



                     Department of Computer Science
                   Texas Southern University, Houston


                        February, 2008
Review of Previous Lectures
 Introduction to programming languages
 Syntax specifications of programming languages
 Semantic specifications of programming
  languages
 Functional Programming
  Properties
  Lambda calculus
 Scheme


                                               2
Today‟s Lecture
 Object-Oriented Programming
    Abstract Data Type
       Objects and classes
    Inheritance, polymorphism
    Virtual methods, dynamic binding
 References
    “Programming Language Pragmatics”, Michael Scott, Chapter 9
    “Concepts of Programming Languages”, John C. Mitchell,
     Chapter 10, 12, & 13
    “Foundations of Programming Languages: Design and
     Implementation”, S. H. Roosta, Chapter 8 & 9


                                                                   3
Features of Object-Oriented
Programming
 Data Abstraction
    “What you can do?” and “How you can do it?” are independent
 Encapsulation
    Information hiding, protect from unauthorized access
 Polymorphism
    Overloading, or same function body but different argument types
 Inheritance
    Reuse of code
 Dynamic Binding
    At run time instead of compile time, a message is attached to a
     method

                                                                       4
Data Abstraction and Object-Oriented

 Modules or Objects/Classes
 Reduces conceptual load by
  modularizing code
 Contains faults to small parts of code
 Makes program components more independent




                                              5
Why Object-Oriented?
 Groups data with code
  Data is isolated in private object fields
  Methods operating on the data are bundled with the
   data in classes
  Other code can‟t mess with the data
  Classes can be easily added or removed from the
   code




                                                        6
Programming Style
 C++
  class C { … public: virtual int foo() { … }}
  class D :public C { virtual int foo() { … }}
  class E :public C { virtual int foo() { … }}
C
  int foo(C * obj) {
     if (obj is a D)
         ... // code from D::foo()
     else if (obj is an E)
         ... // code from E::foo()
     else
         ... // code from C::foo()
  }
                                                 7
Object-Oriented vs. ADT/Functional
Style
 Object-oriented programming
  Extending a data structure is easy
  Adding new code to an existing data
   structure is hard
 ADT/Functional/Imperative Style
  Adding new code is easy
  Extending a data structure is hard




                                         8
Implementation of Object-Oriented
Programming
 User-defined types
  Classes
 Encapsulation
  Private fields – member variables
 Subtype polymorphism
  Inheritance – subclass
  Structural subtyping – override virtual function
 Code reuse
  Inheritance – subclass

                                                      9
What is a Type?
 Built-in types
   int, char, etc.
 Programmer-defined types
   Classes
 Interface types (in Java)
 Think of a type as a set of values
   int = -2^31 .. 2^31-1
   C = set of instances of class C or any
    subclass of C

                                             10
Subtyping
 C is a subtype of B (C <: B)
 or a C object is a B object
 or a C object can be used wherever a
  B object is expected
 or C is more specific than B
 The set of C instances is a subset of
  the set of B instances



                                          11
Implementation of Subtyping
 The layout of a C object includes a B
  object
     p:          B           B *p = new C();
                 C

 If (virtual) methods are overridden,
  we need to select the appropriate
  method at run time – dynamic binding


                                               12
Selection of Virtual Methods
  class B {
     public int foo () { return 0; }
  }
  class C extends B {
     public int foo () { return 1; }
  }
  B obj = new C();
  int i = obj.foo (); /* executes C.foo */



                                             13
Method Selection Algorithm
 Method call
  C * p = new D();
  p->foo(42, p)
 Compile-time overload resolution
  Find the receiver‟s (p‟s) static type (C)
  Inside C find an appropriate method for the static
   types of the arguments ((int,C))
 Run-time virtual method dispatch
  Look up the code for the method signature
   foo(int,C) in the virtual function table
                                                        14
Implementation of Method Dispatch
 Conceptually, an object contains a
  list of pointers to its methods
 C++: the object contains a pointer to
  the virtual function table
 Java: an object pointer consists of a
  pointer to the object and a pointer to
  the dispatch table



                                           15
Structures in Object-Oriented
Programming
  struct S {
     int x;
     float y;                         a:   x = 42
  };
                                           y = 3.14

  S a;
  a.x = 42;
  a.y = 3.14;                         p:

  S *p = &a;                          q:
  S *q = new S;
  int i = p -> x; // i is 42
  int j = q -> x; // j has no value

                                                      16
Methods
 struct S {
    int x;
    float y;
    int getX() { return x; }
 };

 S *p = new S;
 p -> x = 42;
 p -> y = 3.14;
 int i = p -> getX(); // i is 42
                                   17
Constructors
 struct S {
    int x;
    float y;
    S(int a, float b) { x = a; y = b; }
    int getX() { return x; }
 };

 S *p = new S(42, 3.14);
 int i = p -> getX(); // i is 42


                                          18
Visibility Specifiers
  struct S {
    private:
     int x;
     float y;
    public:
     S(int a, float b) { x = a; y = b; }
     int getX() { return x; }
  };

  S *p = new S(42, 3.14);
  int i = p -> getX(); // i is 42
  Int j = p -> x; //??
                                           19
Struct vs. Class
  struct S {       class S {
    private:          ……
     ……            };
  };

  struct S {       class S {
     ……              public:
  };                  ……
                   };


                               20
Inheritance
  Class C {                     C *p = new C(42);
     int x;                     D *q = new D(42, 3);
    public:
     C(int a) { x = a; }              C:         x
     int getX() { return x; }
  };                                  D:         x
  Class D : public C {                           y
     int y;
    public:                         p:        x = 42
     D(int a, int b) : C(a)
        { y = b; }                  q:        x = 42
     int getY() { return y; }                 y=3
  };
                                                       21
Subtyping
 Class D : public C {     ……     };

 C *q = new D(42, 3);

            q:          x = 42        C part
                        y=3

 A D object can be used where a C object is expected

 D *q = new C(42); is not allowed


                                                       22
Virtual Methods
 Class C {                    Class D : public C {
   protected:                    int y;
    int x;                      public:
   public:                       D(int a, int b) : C(a) { y = b; }
    C(int a) { x = a; }          virtual void print () {
    virtual void print () {         cout << „(„ << x << “, “ << y << „)‟;
       cout << x;                }
    }                         };
 };
                              C *p = new D(42, 3);
                              p -> print();


                                                                        23
Virtual Methods (cont‟)
  Conceptually,
            p:            x = 42
                           print          D :: print
                           y=3
  Actual implementation:
    p:           x = 42            C_D_vtable
                  print
                  y=3                            D :: print

  p -> print()     ==> ((*(p -> vtbl))[1])(p)
                                                              24
Function Call vs. Message
Passing
 Function call syntax (C++)
  p.foo(5);
  p->foo(5);
 Message passing syntax (SmallTalk)
  p foo 5.
  6 * 7.
  someArray at: 1 put: 5.
  x = 0 if True: [y <- 1]
         If False: [y <- 2].

                                       25
Typed vs. Untyped
 Statically typed (C++, Java, etc.)
   no „message not understood‟ errors at
    run time
   more efficient dispatch since layout of
    dispatch table is known
 Untyped (SmallTalk, CLOS, Cecil)
   more flexibility
   try to infer types for optimizing dispatch



                                                 26
Abstract Classes (C++)
  class A {
     public:
       virtual int foo () = 0;
  };
  class C : public A { /* ... */ }
 Defines type
 Implementation is supplied in
  subclass


                                     27
Interface Types (Java)
  interface I {
     int foo ();
  }
  class C implements I { /* ... */ }
 Separation of interface and
  implementation
 Cleaner design of type hierarchies



                                       28
Other Design Issues
 Single or multiple inheritance
  C++: class C : public A, public B {};
  Java: class C extends B { }
 C++-style virtual inheritance
  class C : public virtual A { };
  allows objects to share a common part
   from multiple base classes
 Single dispatch or multimethods
  single dispatch: virtual functions
  multiple dispatch: run-time overloading

                                             29
Multiple Inheritance
  class A { int x; };
  class B {
     int y;
     public:
        virtual int foo (int);
  };
  class C : public A, public B {
     int z;
     public:
        virtual int foo (int);
        virtual void bar (int);
  };
                                   30
Implementation of Multiple
Inheritance
 Concatenate all the pieces in layout
 Multiple vtables per object (C++)
     p:          x
                 y
               B_vptr          C :: foo
                 z
               C_vptr          C :: bar



                                          31
Implementation of Multiple
Inheritance (cont‟)
 Adjust `this‟ pointer
   B *p = new C;
   int i = p->foo(42);
 is translated to
   int i = ((p->B_vptr)[1].fn)
           (p+(p->B_vptr)[1].delta, 42)




                                          32
Virtual Inheritance
 Sharing of common part
  class A;
                                      A
  class B : public virtual A;
                                  B       C
  class C : public virtual A;
  class D : public B, public C;       D

 Implementation: B and C parts
  contain pointers to common A part



                                              33
Multimethods
 Instead of run-time method selection
  based on receiver (virtual in C++)
 Run-time method selection based on
  all arguments
 Like overloading but with method
  selection at run time
 Allows different program structure
 Languages: CLOS, Cecil, Brew


                                         34
Multimethod Implementation
 Generic functions dispatch using an
  n-dimensional table lookup
 Example
  int foo (C);
  int foo (D);
  C p = new D();
  int i = foo(p); // calls foo(D)




                                        35
Structural Subtyping or Retroactive
Abstraction
  class C { public int foo () { ... } }
     interface I {
     int foo ();
  }
 Structural Subtyping
  I p = new C();
 Retroactive Abstraction
  class C implements I;
  I p = new C();

                                          36
Signatures in G++
  signature I {
      int foo ();
  };
  class C { public: int foo (); };
  I * p = new C;
 Implemented in G++ Versions 2.6-2.8
 Use „-fhandle -signatures‟ option



                                        37