EEL 3801 - PowerPoint PPT Presentation

About This Presentation
Title:

EEL 3801

Description:

... lname, int bmonth, int bday, int byear, int hmonth, int ... birthdate(bmonth, bday, byear), hiredate(hmonth, hday, hyear) { strncpy(firstname, fname, 24) ... – PowerPoint PPT presentation

Number of Views:66
Avg rating:3.0/5.0
Slides: 63
Provided by: avelinoj
Learn more at: http://www.cs.ucf.edu
Category:
Tags: eel | bday

less

Transcript and Presenter's Notes

Title: EEL 3801


1
EEL 3801
  • Part VI
  • Fundamentals of C and C Programming
  • Classes and Objects

2
Object-Oriented Programming
  • We think in terms of objects.
  • Objects can be
  • animate
  • inanimate
  • Objects have
  • attributes (i.e., color, size, weight, etc.)
  • behaviors (i.e., move, rotate, cry, laugh)
  • communication with other objects

3
C vs C
  • C is a procedural language
  • it revolves around functions
  • functions create motion or action
  • data exists mainly in support of actions
  • C is an object-oriented language
  • it revolves around classes of objects
  • a class is based upon the C structure

4
Classes
  • Similar to structures except that
  • have member functions
  • are capable of inheriting from parent classes
  • Data members are the data components.
  • Member functions are the function components of a
    class.
  • An instance of a class data type is an object.

5
Review of Structures
  • In C, structure data types can be created
    directly through the struct tag.
  • Members can be accessed through the
  • dot operator if directly referenced (a variable)
  • arrow operator if referenced through a pointer.
  • Can be dynamically allocated through the new
    operator.

6
Disadvantages of Structures
  • External programs can directly access the
    structure members.
  • Initialization not required or permitted
    directly.
  • Cannot be printed as a unit.
  • Cannot be compared in their entirety - must be
    compared member by member.
  • No inheritance.

7
Structure Example
  • struct Time
  • int hour
  • int minute
  • int second
  • void printMilitary(const Time )
  • void printStandard(const Time )
  • main()
  • Time dinnertime ...
  • See page 598 of textbook.

8
Classes
  • Defined similarly to a structure, with the
    exception that
  • Uses the class keyword rather than struct.
  • Allows the inclusion of function prototypes
    inside class definition for member functions.
  • Can specify the access of its members
  • private only accessible through member functions
  • public accessible to any part of the program
    that has access to its object.

9
Example of a Class
  • class Time
  • public
  • void setTime(int, int, int)
  • void printMilitary()
  • void printStandard()
  • private
  • int hour
  • int minute
  • int second

10
Classes
  • Now the functions used to print the time are
    included as member functions of the class data
    type Time.
  • Note that the prototypes for the printing
    functions have no need to have the object passed
    to it, as they are part of it.
  • The values of hr, min and sec are set by a member
    function, not by outsiders.

11
Classes
  • The data members are private, thus cannot be
    changed by outside functions (for now).
  • This is called information hiding, and it is an
    important aspect of software engrg.
  • Internal structure is of no concern to the class
    user.
  • Internal modifications to the class are
    transparent to user of the class.

12
Member Functions
  • Member functions can be defined
  • inside the class body (rather than just the
    prototype).
  • Typically done when function body is short
  • outside the class body using the scope resolution
    operator ()
  • Done when definition is long and cumbersome
  • preferable in most cases

13
Types of Member Functions
  • Access functions Used to read or display private
    data for a class. Kept public.
  • Predicate functions Used to determine truth or
    falsity of certain class data members or other
    class states. For example, list is full.
  • Utility functions Used to carry our a task not
    directly related to private data members. Can be
    kept as private, as client has no need.

14
Class Scope
  • Variable and function names declared inside a
    class definition belong to that class scope
  • So the operator must be used for defining
    member functions if outside the class def.
  • This allows for other classes to have functions
    of the same name.
  • Functions defined inside a class definition are
    automatically inlined by the class.

15
Class Scope
  • Non-member functions have file scope.
  • Within a classs scope, all members can be
    referenced directly by name by the member
    functions.
  • Outside a classs scope, data members (that are
    public) are accessed only through a reference or
    a pointer to an object of that class.

16
Class Scope
  • Member functions have function scope within their
    class.
  • If member function defines a variable with same
    name as a variable with class scope, the
    class-scope variable is hidden by the
    function-scope variable within the function
    scope.
  • Such a hidden class scope variables can be
    accessed with the scope resolution operator by
    preceding the operator with the class name.

17
Class Scope
  • Hidden global variables can be likewise accessed
    from inside a class where another variable has
    the same name through the use of the unary scope
    resolution operator (i.e., the class name is
    omitted from before the operator)
  • dinnerTimehour
  • vs
  • hour

18
Example
  • include ltiostream.hgt
  • class Count
  • public
  • int x
  • void print() cout ltlt x ltlt \n
  • main()
  • Count counter
  • Count ctrptr counter
  • Count ctrref counter

19
Example
  • counter.x 7
  • counter.print()
  • ctrref.x 8
  • ctrref.print()
  • ctrptr-gtx 10
  • ctrptr-gtprint()

20
Example
  • The results obtained after running that program
    are
  • 7
  • 8
  • 10
  • Keep in mind that in this case, the data member x
    was made public. Thus, it was able to be
    accessed directly from main() through . or -gt.
    This is not typical.

21
Interface
  • Class definitions are typically placed in a
    header (.h) file.
  • Place the definition of the member functions as a
    source file (.cpp) to be compiled.
  • That way, the customer can be given the object
    code for the .cpp file and not reveal the
    proprietary source code.

22
Controlling Access to Members
  • An important part of C and OOP.
  • Outside access to a classs data members and
    member functions can be controlled
  • public
  • private
  • protected
  • Default mode is private

23
Controlling Access to Members
  • Therefore, all members after class header and
    before next label are private
  • After each label, the access mode defined by that
    label applies until next label or .
  • Labels may be repeated, but that is rare.

24
Controlling Access to Members
  • private members - can only be accessed by other
    members of the same class or those of a friend
    class (later).
  • public members can be accessed by any function
    in the program through the . or -gt operators.
    Provide the services or public interfaces of that
    class.
  • protected (later - Chapter 19 - Inherit.)

25
Controlling Access to Members
  • Private members of a class, as well as the
    definitions of public member functions, are not
    accessible to the clients of a class.
  • For the Time class defined previously
  • main()
  • Time t
  • t.hour 7 // error - hour is private.
  • t.printMilitary() // no error

26
Good Practice
  • A client may be a global function or another
    classs member function.
  • Keep all data members of a class as private.
  • Keep all access to private data members through
    public member functions.
  • Access private members through set() or get()
    member functions that are public.
  • Can serve to check data validity and hide data
    forms from client.

27
Controlling Access to Members
  • Keep all public members together and first in the
    class definition.
  • Keep all private members together and second in
    the class definition - explicit.
  • C structures and unions have a public default
    access.
  • For a structure, can be changed to private and
    protected (?).

28
Private Functions
  • Not all member functions have to be public.
  • Functions used as utility functions by other
    member functions can be kept private.

29
Constructor Functions
  • Member functions that have the same name as the
    class.
  • Invoked automatically when an instance of a class
    is created (an object).
  • Data members cannot be initialized in the class
    definition - it is only an abstract class!
  • Constructors can be used to initialize data
    members of a class instance.

30
Constructor Functions
  • Cannot return anything.
  • May be overloaded.
  • Can have arguments passed to it. Such arguments
    can be specified in the declaration of the
    instance level object, to the right of the object
    name and within parentheses, but before the
    semicolon.

31
Constructor Functions
  • Can contain default arguments - values placed in
    the prototype itself which sets the value of each
    of the arguments if no other values are specified
    when the instance level object is created.
  • If no constructor function is defined, compiler
    creates a default constructor.
  • Default constructor does nothing useful.

32
Example - Constructor Functions
  • class Time
  • public
  • Time(int0, int0, int0)
  • void setTime(int, int, int)
  • void printMilitary()
  • void printStandard()
  • private
  • int hour
  • int minute
  • int second

33
Example - Constructor Functions
  • TimeTime(int hr, int min, int sec)
  • hour (hrgt0 hr lt24) ? hr 0
  • minute(mingt0 minlt60) ? min 0
  • second(secgt0 seclt60) ? sec 0
  • The constructor above ensures validity of
    initialized value.
  • Sets to 0 if hr, min or sec not specified,

34
Example - Default Arguments
  • main()
  • Time t1, t2(2), t3(21,34)
  • Time t4(12,25,42), t5(27,74,99)
  • t1.printMilitary()
  • t1.printStandard()
  • t2.printMilitary()
  • t2.printStandard()

35
Example - Default Arguments
  • t3.printMilitary()
  • t3.printStandard()
  • t4.printMilitary()
  • t4.printStandard()
  • t5.printMilitary()
  • t5.printStandard()

36
Example - Default Arguments
  • For t1
  • 000000
  • 120000 midnight
  • For t2
  • 020000
  • 20000 AM
  • For t3
  • 213400
  • 93400 PM

37
Example - Default Arguments
  • For t4
  • 122542
  • 122542 PM
  • For t5
  • 000000
  • 120000 midnight
  • (values were illegal, so they were set to 0)

38
Destructors
  • Have same name as class but with a tilde in
    front.
  • Invoked automatically when class instance leaves
    scope (is deleted).
  • Does not per se delete the object, but performs
    termination housekeeping.
  • Has no parameters and returns no value.
  • Only one per class cannot be overloaded.

39
Destructors
  • Not used with simple classes.
  • Used when dynamically allocated memory must be
    deleted.
  • Called when their object leaves scope.

40
Things to Not Do
  • Do not design a public member function to return
    a reference to a private data member.
  • This compromises the integrity of the data
    member, since a reference is an alias, so that
    anything we do to it we do to the original
    variable.
  • See Textbook pages 626 to 629.

41
Constant Objects and Functions
  • Preceding the class object instantiation with the
    operator const will make the object a constant
    object.
  • This means that no member function will be
    allowed to be called - rather harsh!!
  • But often, the programmer only means to disable
    changing the values of the members, and not
    prohibiting get access to data.

42
Constant Objects and Functions
  • To provide access, but not modification rights
    for a particular object
  • the programmer may declare const member
    functions.
  • These cannot modify the object.
  • Only these can operate on const objects.
  • But this can be tricky

43
const Functions
  • A member function is specified as const by doing
    both
  • specifying it as const in its declaration in the
    class, and
  • inserting the keyword const in its definition
    after the functions parameter list and before
    the left brace begins the functions body.
  • A const member function can be overloaded with a
    non-const version

44
const Functions
  • Example
  • class Whatever
  • .
  • .
  • int getvalue() const
  • int Whatevergetvalue() const return
    private_data

45
Initialization of const Objects
  • Constructor functions in a const object must be
    allowed to modify the data members, as they must
    be somehow initialized.
  • Constructors need not be const.
  • But since the values of a const object cannot be
    modified by assignment
  • A member initializer must be used.

46
Member Initializers
  • Used with Constructor member function.
  • Use the notation
  • initialized_variable(init_val)
  • This should be done after the parameter list but
    before the function body opening brace of the
    Constructor member function.

47
Example of Initializer
  • class Increment
  • public
  • Increment(int c0, int i1)
  • void addinc() count increment
  • void print() const
  • private
  • int count
  • const int increment
  • IncrementIncrement(int c, int i)
  • increment(i)
  • count c

48
Potential Errors in const Objects
  • Defining as const a member function that modifies
    a data member of a non-const object.
  • Defining as const a member function that calls a
    non-const member function.
  • Calling a non-const member function for a const
    object.
  • Attempting to modify a const object

49
Nested Classes
  • Classes can be members of other classes.
  • This is referred to as composition.
  • Straight forward, except at initialization.
  • When an object enters scope, its constructor is
    immediately invoked to initialize it.
  • Member objects are constructed before their
    enclosing objects are constructed.

50
Example of Nested Classes
  • The member objects parent class
  • class Date
  • public
  • Date(int1, int1, int1900)
  • void print() const
  • private
  • int month
  • int day
  • int year
  • int checkDay(int)

51
Example of Nested Classes
  • The Constructor Function
  • DateDate(int mn, int dy, int yr)
  • month (mn gt 0 mn lt 12) ? mn 1
  • year yr
  • day checkDay(dy) // validates day

52
Example of Nested Classes
  • The enclosing class note the 6 int args
  • class Employee
  • public
  • Employee(char , char , int, int, int, int,
    int, int)
  • void print() const
  • private
  • char lastname25
  • char firstname25
  • Date birthdate
  • Date hiredate

53
Example of Nested Classes
  • Now, for the Constructor function
  • EmployeeEmployee(char fname, char lname, int
    bmonth, int bday, int byear, int hmonth, int
    hday, int hyear)
  • birthdate(bmonth, bday, byear),
  • hiredate(hmonth, hday, hyear)
  • strncpy(firstname, fname, 24)
  • firstname24 \0
  • strncpy(lastname, lname, 24)
  • lastname24 \0

54
Friend Functions and Classes
  • A function that is not a member function of a
    particular class, but which has access to private
    and protected members of that class is called a
    friend function.
  • A friend class is one all of whose functions have
    access to another classs private (and protected)
    members.

55
Friend Functions and Classes
  • Friendship is granted, not taken.
  • The class giving friend privileges must declare
    the friend class to be a friend
  • For class B to be a friend of class A, class A
    must declare that class B is its friend.
  • Friendship is neither symmetric or transitive

56
Friend Functions and Classes
  • To declare such a friend function
  • precede the function prototype in the friend
    class definition with the keyword friend.
  • Define the function outside the friend class,
    with no scope resolution operator.
  • To declare class A as a friend of class B, place
    a declaration of the form friend class A as a
    member of class B.

57
Friend Functions and Classes
  • The labels public, private and protected do
    not affect the friend declaration.
  • Therefore, it does not matter where the friend
    declaration is placed.

58
Example of Friends
  • class Count
  • friend void setx(Count , int)
  • public
  • Count() x 0
  • void print() const ..
  • private
  • int x
  • void setx(Count c, int val)
  • c.x val // no need for set() func

59
Friend Functions and Classes
  • Note that in the previous example, the object
    instance of the friendly class is passed to the
    friend function.
  • A function can be a friend of more than one
    class, but a member of at most one class.
  • Friend classes are much less common than friend
    functions

60
Friend Classes
  • class Parttime
  • class Employee
  • public
  • friend class Parttime
  • private
  • char name30
  • int x
  • The friend class can be put anywhere.

61
The This Pointer
  • Every object has a pointer, called the this
    pointer, that points to itself.
  • It is needed because only one copy of an classs
    member function exist. No copies are made for
    each object instantiated.
  • Data members, however, are cheaper, so each
    object has their own data members.

62
Static Data Members
  • Allows one data member of one class to be shared
    by all object instances of that class.
  • Seem like global variables but have class scope.
  • Can be public, private or protected.
  • See page 661-665 of Deitel Deitel for details.
Write a Comment
User Comments (0)
About PowerShow.com