Post on 31-Dec-2015
CS212: Object Oriented Analysis and Design
Lecture 6: Friends, Constructor and destructors
Recap of Lecture 5
• Scope of class members
• Nesting member function
• Class members and arrays
• Static class members
Today’s objective
• Friendly classes and function
• Constructors
• Default Argument
• Destructors
Friend function
• A friend function of a class is defined outside that class' scope but it has the right to access all private and protected members of the class.
• Even though the prototypes for friend functions appear in the class definition, friends are not member functions.
• A friend can be a function, function template, or member function, or a class or class template
Properties of friend functions
• Friend of the class can be member of some other class.
• Friend of one class can be friend of another class or all the classes in one program: GLOBAL FRIEND.
• Can access the private or protected members of the class in which they are declared to be friend, but they can use the members for a specific object
• Do not get “this” pointer.
• Can be friend of more than one class, hence they can be used for message passing between the classes.
• Can be declared anywhere (in public, protected or private section) in the class.
When to use friend function
• Three different circumstances where friend functions are useful
• Operator overloading - for certain types of operators
• Creation of I/O operations
• Multiple classes share common functionality
Friend Class
• Friendship may allow a class to be better encapsulated by granting per-class access to parts of its API that would otherwise have to be public.
• This increased encapsulation comes at the cost of tighter coupling between classes
• Friendships are not symmetric
• Friendships are not transitive
• Friendships are not inherited
• Access due to friendship is inherited
Constructors
void foo()
{
int n = 5;
double z[10] = { 0.0 };
struct gizmo { int i, j; } w = { 3, 4 };
·····
}
• All of the variables are created at block entry when foo() is invoked.
• Uses a runtime system stack.
• The class needs a mechanism to specify object creation and destruction so that a client can use objects like native types.
Constructors
• It is a member function whose name is the same as the class name
• It creates objects of the class type
• It involves initializing data members
• Allocating storage from the heap by using new.
• The simplest use of a constructor is for initialization.
• Demonstration
Implicit Constructor
• An implicitly-declared default constructor is an inline public member of its class
• It performs the initialization operations that are needed by the implementation to create an object of this type.
• These operations do not involve initialization of user-declared data members or allocation of memory from the free store
• Demonstration
Parameterized Constructors
• It may be necessary to initialize different member variables with different values
• To achieve this we can pass arguments to a constructor
• The constructor that can take arguments are called parameterized constructors
• Implicit and Explicit calling of parameterized constructors
• Demonstration
Multiple Constructors in a Class
• There can be multiple constructors in a class
• Each function has its own significance
• In some cases it is necessary to have both parameterized and default constructors
• Avoid Reduplicating Identical Pieces Of Constructors' Code
Efficient constructor design
class string{private:
char * pc;size_t capacity;size_t length;enum { DEFAULT_SIZE = 32};
public:string(const char * s);string(size_t initial_capacity );string();
//...};
Efficient … (contd.)
class string{
private:char * pc;size_t capacity;size_t length;enum { DEFAULT_SIZE = 32};
// following function is called by every constructorvoid init( size_t cap = DEFAULT_SIZE);
public:string(const char * s);string(size_t initial_capacity );string();//...other member functions};
void string::init( size_t cap){
pc = new char[cap];capacity = cap;
}
Efficient … (contd.)string::string(const char * s){
size_t size = strlen (s);init(size + 1); length = size;strcpy(pc, s);
}string::string(size_t initial_capacity ){
init(initial_capacity);length=0;
}string::string(){
init();length = 0;
}
Default Argument
class Fraction{private: int m_nNumerator; int m_nDenominator; public: // Default constructor Fraction(int nNumerator=0, int nDenominator=1) { m_nNumerator = nNumerator; m_nDenominator = nDenominator; } int GetNumerator() { return m_nNumerator; } int GetDenominator() { return m_nDenominator; }};
A special case
• Applicable to constructor with exactly one parameter
• Implicit type conversion
• Demonstration
Is A Default Constructor Always Necessary?
• The existence of a user-defined constructor blocks the synthesis of an implicitly-declared default constructor.
• A class with no default constructor limits its users to a narrower set of allowed uses.
• Demonstration
Constant Object
• Class objects can be made constant using the const keyword
• Constant variables must be initialized at time of creation
• In the case of classes, this initialization is done via constructors
• Once initialized via constructor, any attempt to modify the member variables of the object is disallowed
• It would violate the const(ant)-ness of the object
Constant object
• Changing member variables directly (if they are public) is not allowed
• Calling member functions that sets the value of member variables is not allowed
• const class objects can only call const member functions
Trivial Constructors
• Compilers synthesize a default constructor for every class unless a constructor was already defined by the user
• Such a synthesized constructor is redundant
• A constructor is considered trivial when all the following hold true:
• Its class has no virtual member functions and no virtual base classes.
• All the direct base classes of the constructor's class have trivial constructors.
• All the member objects in the constructor's class have trivial constructors.
Destructors
• It is a member function whose name is the class name preceded by the tilde ~ character
• A destructor’s usual purpose is finalizing or destroying objects of the class type.
• Finalizing objects involves retrieving resources allocated to the object.
• Requires using delete to deallocate store assigned to the object.
• They can not be overloaded or take arguments
When constructor and destructors are called
• An object's constructor is called when the object comes into existence
• An object's destructor is called when the object is destroyed
• For a local object: constructor object's declaration,
destructor reverse order of constructor
• For a global object: constructor before main(), , in order of their declaration, within the same file
destructor reverse order of constructor, after main() has terminated
Thank youNext Lecture: Arrays, Pointers and Dynamic Allocation