What is a protocol class?
An abstract class is a protocol class if:
Ø it neither contains nor inherits from classes that contain member data,
non-virtual functions, or private (or protected) members of any kind.
Ø it has a non-inline virtual destructor defined with an empty
Ø all member functions other than the destructor including inherited
functions, are declared pure virtual functions and left undefined.
What is a mixin class?
A class that provides some but not all of the implementation for a virtual base
class is often called mixin. Derivation done just for the purpose of redefining
the virtual functions in the base classes is often called mixin inheritance.
Mixin classes typically don't share common bases.
What is a concrete class?
A concrete class is used to define a useful object that can be instantiated as
an automatic variable on the program stack. The implementation of a concrete
class is defined. The concrete class is not intended to be a base class and no
attempt to minimize dependency on other classes in the implementation or
behavior of the class.
What is the handle class?
A handle is a class that maintains a pointer to an object that is
programmatically accessible through the public interface of the handle class.
In case of abstract classes, unless one manipulates the objects of these classes
through pointers and references, the benefits of the virtual functions are lost.
User code may become dependent on details of implementation classes because an
abstract type cannot be allocated statistically or on the stack without its size
being known. Using pointers or references implies that the burden of memory
management falls on the user. Another limitation of abstract class object is of
fixed size. Classes however are used to represent concepts that require varying
amounts of storage to implement them.
A popular technique for dealing with these issues is to separate what is used as
a single object in two parts: a handle providing the user interface and a
representation holding all or most of the object's state. The connection between
the handle and the representation is typically a pointer in the handle. Often,
handles have a bit more data than the simple representation pointer, but not
much more. Hence the layout of the handle is typically stable, even when the
representation changes and also that handles are small enough to move around
relatively freely so that the user needn’t use the pointers and the references.
What is an action class?
The simplest and most obvious way to specify an action in C++ is to write a
function. However, if the action has to be delayed, has to be transmitted
'elsewhere' before being performed, requires its own data, has to be combined
with other actions, etc then it often becomes attractive to provide the action
in the form of a class that can execute the desired action and provide other
services as well. Manipulators used with iostreams is an obvious example.
A common form
of action class is a simple class containing just one virtual function.
virtual int do_it( int )=0;
virtual ~Action( );
Given this, we can write code say a member that can store actions for later
execution without using pointers to functions, without knowing anything about
the objects involved, and without even knowing the name of the operation it
invokes. For example:
class write_file : public Action
return fwrite( ).suceed( );
class error_message: public Action
response_box db(message.cstr( ),"Continue","Cancel","Retry");
switch (db.getresponse( ))
case 0: return 0;
case 1: abort();
case 2: current_operation.redo( );return 1;
A user of the Action class will be completely isolated from any knowledge of
derived classes such as write_file and error_message.
When can you tell that a memory leak will
A memory leak occurs when a program loses the ability to free a block of
dynamically allocated memory.
What is a parameterized type?
A template is a parameterized construct or type containing generic code that can
use or manipulate any type. It is called parameterized because an actual type is
a parameter of the code body. Polymorphism may be achieved through parameterized
types. This type of polymorphism is called parameteric polymorphism. Parameteric
polymorphism is the mechanism by which the same code is used on different types
passed as parameters.
Differentiate between a deep copy and a
Deep copy involves using the contents of one object to create another instance
of the same class. In a deep copy, the two objects may contain ht same
information but the target object will have its own buffers and resources. the
destruction of either object will not affect the remaining object. The
overloaded assignment operator would create a deep copy of objects.
Shallow copy involves copying the contents of one object into another instance
of the same class thus creating a mirror image. Owing to straight copying of
references and pointers, the two objects will share the same externally
contained contents of the other object to be unpredictable.
Using a copy constructor we simply copy the data values member by member. This
method of copying is called shallow copy. If the object is a simple class,
comprised of built in types and no pointers this would be acceptable. This
function would use the values and the objects and its behavior would not be
altered with a shallow copy, only the addresses of pointers that are members are
copied and not the value the address is pointing to. The data values of the
object would then be inadvertently altered by the function. When the function
goes out of scope, the copy of the object with all its data is popped off the
If the object has any pointers a deep copy needs to be executed. With the deep
copy of an object, memory is allocated for the object in free store and the
elements pointed to are copied. A deep copy is used for objects that are
returned from a function.
Page Numbers :