C - Lecture 2

1
C - Lecture 2

• Function Overloading
• Default Functions arguments
• Thinking about objects relationship to classes
• Types of member functions
• Constructor and destructor functions
• Constant functions
• Inline functions
• Microsoft Visual C demonstration

2
Function overloading

• In C it is possible to have several functions
  all with the same name provided that they differ
  in the number and/or type of their arguments.
• The compiler is able to select the correct
  function to call based on the number and type of
  the arguments used in the actual function call.
• A difference in the return type is not used to
  differentiate between functions
• Function overloading can be used for any
  functions but is often used in constructor
  functions.

3
Function overloading

• void func(int x)
• cout ltlt x ltlt squared is ltlt x x ltlt endl
• void func (int x, int y)
• if (xgty)
• cout ltlt x ltlt is biggest ltlt endl
• else
• cout ltlt y ltlt is biggest ltlt endl
• func(42) // would call first function
• func(22,44) //would call second function

4
Default function arguments

• Normally when a function is called all the
  arguments that are required by the function must
  be present.
• In C the function can be made to use a default
  value is the argument is not provided when the
  function is called.
• There are some restrictions
• Default arguments should be used sparingly
• Default arguments are often used with constructor
  functions in classes

5
Default function arguments

• A default value is assigned in the function
  declaration only (not the function definition)
• E.g. void car (int capacity, int cylinders 4,
  int seats 5)
• Now the function can be called -
• the normal way - car(2000, 6, 4) // override
  default values
• or car(2000) provide first argument and use the
  default value for the others
• or car(3000,6) provide first 2 arguments and use
  the default value for the third
• but NOT car(3000, ,3) // NOT ALLOWED!!

6
Thinking about objects

• What are the attributes/properties of the object
• The attributes become the data members of the
  class
• These are normally placed in the private section
  of the class
• Private data is only accessible only by class
  member functions
• What actions and behaviours does the object have
• The actions/behaviours become the member
  functions of the class
• The member functions are normally placed in the
  public section of the class

7
Member functions

• There are 3 types of member functions that we can
  identify
• mutator these modify the member data
• accessor these access the member data but do
  not change it i.e. read only access
• manager provide house-keeping for the class
  itself
• To allow users of the class to access the private
  data in a controlled way the following types of
  member functions are often provided in a class
• set_memberdata(data_type a_value) // A mutator
  function
• data_type get_memberdata() // An accessor
  function

8
Member functions

• A class member function is placed in the private
  section if it is only used internally by the
  class and the users of the class should not be
  allowed to use the function directly
• Data can be placed in the public section of the
  class. This however is poor programming practice
  and goes against the idea of data hiding and
  encapsulation.

9
Constructors and destructors

• At present when an object is created (i.e. an
  instance of a class) the member variables will
  have random values.
• It is preferred to have objects created in a
  particular known state.
• Constructor functions are used.
• Constructor functions are automatically called
  when an object needs to be created.
• When an object goes out of scope and is no longer
  required a destructor function is automatically
  called to perform any clean-up that may be
  required.

10
Constructors

• A constructor function has the same name as the
  class.
• The constructor has no return type not even void.
• The constructor may take zero or more arguments
• A constructor requiring NO arguments is called
  the default constructor.
• The constructor function is often overloaded
• The constructor may often use default arguments.
• If a constructor is not provided a default
  constructor is provided by the compiler that does
  nothing.
• When a copy of an existing object is required
  (e.g. passing an object by value to a function) a
  copy constructor is invoked.
• If no copy constructor is provided the compiler
  provides one that does a member-wise copy of all
  the member variables. (Often this is sufficient)

11
Destructors

• The destructor function has the same as the class
  but preceded by the tilde character
• The destructor has no return type
• The destructor takes no arguments
• Therefore destructor cannot be overloaded

12
Copy Constructor

• A copy constructor is automatically called when
  an object needs to be copied. E.g. Consider
  passing objects to functions-
• someclass x // x is an instance of someclass
• func(x) // call func passing the object x
• //The function func
• void func(someclass f_arg)
• // do something with f_arg
• This is pass by value i.e. f_arg is a copy of x
• The compiler will automatically construct f_arg
  and call the copy constructor to copy the data
  member variables of x into f_arg
• We will look at copy constructor functions later.

13
Example class cpatient.h

• if ! defined cpatient_h
• define cpatient_h
• class CPatient
• public
• CPatient(const char n, int a, char g)
• CPatient() // default constructor
• CPatient()
• void set_name(char n)
• void set_age(int a)
• void set_gender(char g)
• void identify() // display all member variables
• const char get_name()
• int get_age()
• char get_gender()
• private
• char name30
• int age
• char gender

14
cpatient.cpp

• include cpatient.h
• include ltiostreamgt
• include ltstring.hgt // old c string functions
• using namespace std
• CPatient CPatient(const char n, int a, char
  g) // Normal constructor
• //cout ltlt constructing patient ltlt endl
• strcpy(name,n)
• age a
• gender g
• CPatient CPatient() //default constructor
  no arguments
• //cout ltlt default constructor ltlt endl
• strcpy(name,A.N.Other)
• age 0
• gender M

15
cpatient.cpp (cont.)

• CPatient CPatient() //destructor
  does nothing
• void CPatient identify()
• cout ltlt "Name " ltlt name ltlt endl
• cout ltlt "Age " ltlt age ltlt endl
• cout ltlt "Gender " ltlt gender ltlt endl ltlt endl
• void CPatient set_name(char n)
• strcpy(name,n)
• void CPatient set_age(int a) age a
• void CPatient set_gender(char g) gender g

16
cpatient.cpp (cont.)

• const char CPatient get_name()
• return name
• int CPatient get_age()
• return age
• char CPatient get_gender()
• return gender

17
main.cpp

• include ltiostreamgt
• include cpatient.h
• using namespace std
• cpatient x //global cpatient object
• void main()
• CPatient a(Arthur, 42, M) // create local
  cpatient object
• a.identify()
• x.identify()
• a.set_age(34)
• a.set_name(Arthur Dent)
• a.identify()
• char g a.get_gender()
• if (g M)
• cout ltlt Mr.
• else
• cout ltlt Ms.
• cout ltlt a.get_name()
• // etc.

18
More class features constant functions

• If a class member function does not modify any of
  the class member variables (i.e. an accessor
  function) then it is good programming practice to
  make it a constant member function by adding the
  keyword const in both the function declaration
  and the function definition.
• Member functions identify, get_name, get_age and
  get_gender are accessor funtions
• E.g. modifications to identify function
• declaration - void identify() const
• definition - void CPatientidentify() const

19
More class features inline functions

• inline function
• Compiler replaces function call with actual code
  of the function body
• Can produce larger programs if function has many
  statements
• Can be more efficient if function is a very
  simple one line statement
• avoids stacking and unstacking of function
  arguments and therefore produce faster execution
• functions that are defined in the class
  definition are implicitly inline
• Any function can be explicitly made an inline
  function by preceding the function with the
  inline keyword

20
Example use of inline keyword

• class CAny
• public
• void func1( ) // normal function call
• void func2( ) x 2 // implicitly inline
• inline void func3( ) //explicitly inline
• private
• int x

• CPP File
• void CAny func1()
• x 1
• inline CAnyfunc3()
• x 3

• Program code
• CAny b
• b.func1( ) // calls the member function func1
• b.func2( ) // compiler places the statement to
  modify x inline
• b.func3( ) // compiler places the statement to
  modify x inline

21
Summary

• Function Overloading - constructors
• Default Functions arguments - constructors
• C class - Abstraction Encapsulation
• Construction of objects
• Constant functions defensive programming
• Inline functions

22
Microsoft Visual C

• Support for C classes
• Demonstration
• Example programs