#OOP_D_ITS - 5th - C++ Oop Operator Overloading
Upcoming SlideShare
Loading in...5
×
 

#OOP_D_ITS - 5th - C++ Oop Operator Overloading

on

  • 3,718 views

 

Statistics

Views

Total Views
3,718
Views on SlideShare
3,711
Embed Views
7

Actions

Likes
2
Downloads
110
Comments
1

2 Embeds 7

http://www.slideshare.net 5
http://www.linkedin.com 2

Accessibility

Upload Details

Uploaded via as Microsoft PowerPoint

Usage Rights

© All Rights Reserved

Report content

Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel

11 of 1

  • Full Name Full Name Comment goes here.
    Are you sure you want to
    Your message goes here
    Processing…
  • thx alot
    Are you sure you want to
    Your message goes here
    Processing…
Post Comment
Edit your comment
  • All but . .* ?: ::Good Programming Practices:Overload operators so that they mimic the behavior of primitive data types.Overloaded binary arithmetic operators shouldreturn const objects by valuebe written as non-member functions when appropriate to allow commutativitybe written as non-friend functions (if data member accessors are available)Overload unary operators as member functions.Always overload <<Always overload = for objects with dynamic data members.

#OOP_D_ITS - 5th - C++ Oop Operator Overloading #OOP_D_ITS - 5th - C++ Oop Operator Overloading Presentation Transcript

  • C++ OOP :: Operator Overloading
    06/10/2009
    1
    Hadziq Fabroyir - Informatics ITS
  • Function Signatures
    A function signature is what the compiler and linker use to identify a function.
    In C , functions are identified only by their name
    In C++ , a function’s signature includes its name, parameters, and (for member functions) const. It does NOT include the return type.
    06/10/2009
    Hadziq Fabroyir - Informatics ITS
    2
  • Ex: C++ swap( ) Function
    We still need separate functions, but they can all have the same name.
    For Examples:
    void swap (int& a, int& b);
    void swap (double& a, double& b);
    void swap (struct bob& a, struct bob& b);
    06/10/2009
    Hadziq Fabroyir - Informatics ITS
    3
  • Operator Overloading Overview
    Many C++ operator are already overloaded for primitive types. Examples:
    + - * / << >>
    It is often convenient for our classes to imitate the operations available on primitive types (e.g., + or - ).
    Then we can use the same concise notation for manipulating our objects.
    06/10/2009
    Hadziq Fabroyir - Informatics ITS
    4
  • Ex: Complex Number Class
    class Complex {public:
    Complex (int real = 0, int imagine = 0);
    int getReal ( ) const;
    int getImagine ( ) const;
    void setReal (int n);
    void setImagine (int d);
    private:
    int real;
    int imagine;
    };
    06/10/2009
    Hadziq Fabroyir - Informatics ITS
    5
  • Using Complex Class
    It makes sense to want to perform mathematical operations with Complex objects.
    Complex C1 (3, 5), C2 (5, 9), C3;
    C3 = C1 + C2; // addition
    C2 = C3 * C1; // subtraction
    C1 = -C2; // negation
    06/10/2009
    Hadziq Fabroyir - Informatics ITS
    6
  • Operators Are Really Functions
    For user-defined types, when you use an operator, you are making a function call.
    Consider the expression: C2 + C1
    This is translated into a function call.
    The name of the function is “operator+”
    The call is:
    C2.operator+(C1);
    06/10/2009
    Hadziq Fabroyir - Informatics ITS
    7
  • Declaring operator+As a Member Function
    class Complex {
    public:
    const Complex
    operator+ (const Complex &operand) const;

    };
    Note all of the const’s!
    06/10/2009
    Hadziq Fabroyir - Informatics ITS
    8
  • operator+ Implementation
    const Complex
    Complex :: operator+ (const Complex &operand) const
    {
    Complex sum;
    // accessor and mutators not required
    sum.imagine = imagine + operand.imagine;
    // but preferred
    sum.setReal( getReal( ) + operand.getReal ( ) );
    return sum;
    }
    06/10/2009
    Hadziq Fabroyir - Informatics ITS
    9
  • Using operator+
    We can now write
    C3 = C2 + C1;
    We can also use cascading operators.
    C4 = C3 + C2 + C1;
    And we can write
    C3 = C2 + 7;
    But C3 = 7 + C2 is a compiler error. (Why?)
    06/10/2009
    Hadziq Fabroyir - Informatics ITS
    10
  • operator+ As aNon-member, Non-friend
    const Complex
    operator+ (const Complex &lhs, // extra parameter
    const Complex &rhs) // not const
    { // must use accessors and mutators
    Complex sum;
    sum.setImagine (lhs.getImagine( )
    + rhs.getImagine( ) );
    sum.setReal (lhs.getReal ( ) + rhs.getReal( ) );
    return sum;
    } // is now commutative
    06/10/2009
    Hadziq Fabroyir - Informatics ITS
    11
  • Printing Objects
    Each object should be responsible for printing itself.
    This guarantees objects are always printed the same way.
    It allows us to write intuitive output code:
    Complex C5 (5, 3);cout << C5 << endl;
    06/10/2009
    Hadziq Fabroyir - Informatics ITS
    12
  • Operator<<
    The insertion operator << is a function and can (and should) be overloaded. We can do operator>>, too.
    << is a binary operator.
    The left-hand operand is of type ostream&
    Therefore, operator<< cannot be a member function. It must be a non-member.
    06/10/2009
    Hadziq Fabroyir - Informatics ITS
    13
  • operator<<
    ostream&
    operator<< (ostream& out, const Complex& c) {
    out << c.getReal( );
    int imagine = c.getImagine( );
    out << (imagine < 0 ? “ - ” : “ + ” )
    out << imagine << “i”;
    return out;
    }
    06/10/2009
    Hadziq Fabroyir - Informatics ITS
    14
  • Operator<<Returns Type ‘ostream &’
    Why? So we can write statements such as
    cout << C5 << “is a complex number”
    OR
    cout << C3 << endl << C2 << endl;
    << associates from left to right.
    06/10/2009
    Hadziq Fabroyir - Informatics ITS
    15
  • Overloading Unary Operators
    Complex C1(4, 5), C2;
    C2 = -C1;
    is an example of a unary operator (minus).
    We can and should overload this operator as a member function.
    06/10/2009
    Hadziq Fabroyir - Informatics ITS
    16
  • Unary operator-
    const Complex Complex :: operator- ( ) const
    {
    Complex x;
    x.real = -real;
    x.imagine = imagine;
    return x;
    }
    06/10/2009
    Hadziq Fabroyir - Informatics ITS
    17
  • Overloading =
    Remember that assignment performs a memberwise (shallow) copy by default.
    This is not sufficient when a data member is dynamically allocated.
    =must be overloaded to do a deep copy.
    06/10/2009
    Hadziq Fabroyir - Informatics ITS
    18
  • Restrictions
    Most of operators can be overloaded.
    You can’t make up your own operators.
    You can’t overload operators for primitive types (like int).
    You can’t change the precedence of an operator.
    You can’t change the associativity of an operator.
    06/10/2009
    Hadziq Fabroyir - Informatics ITS
    19
  • Converting between Types
    Cast operator
    Convert objects into built-in types or other objects
    Conversion operator must be a non-static member function.
    Cannot be a friend function
    Do not specify return type
    For user-defined class A
    A::operator char *() const; // A to char
    A::operator int() const; //A to int
    A::operator otherClass() const; //A to otherClass
    When compiler sees (char *) s it calls
    s.operator char*()
    06/10/2009
    Hadziq Fabroyir - Informatics ITS
    20
  • Good Programming Practices
    Overload operators so that they mimic the behavior of primitive data types.
    Overloaded binary arithmetic operators should
    return const objects by value
    be written as non-member functions when appropriate to allow commutativity
    be written as non-friend functions (if data member accessors are available)
    Overload unary operators as member functions.
    Always overload <<
    Always overload = for objects with dynamic data members.
    06/10/2009
    Hadziq Fabroyir - Informatics ITS
    21
  • Another Example
    Vectors in the Plane
    Suppose we want to implement vectors in 2D and the operations involving them.
    06/10/2009
    Hadziq Fabroyir - Informatics ITS
    22
  • For your practice …
    Exercise
    Vector2D Class
    Properties: double X, double Y
    Method (Mutators): (try) all possible operators that can be applied on Vector 2D
    (define methods of) the remains operation that can’t be overloaded
    Lab Session for lower order (Senin, 15.00-17.00)
    Lab Session for upper order (Senin, 19.00-21.00)
    Please provide:
    the softcopy(send it by email – deadline Sunday 23:59)
    the hardcopy(bring it when attending the lab session)
    06/10/2009
    Hadziq Fabroyir - Informatics ITS
    23
  • ☺~ Next: C++ OOP :: Inheritance ~☺
    [ 24 ]
    Hadziq Fabroyir - Informatics ITS
    06/10/2009