Polymorphism and Types of Polymorphism Assignment Help

C++ Programming - Polymorphism and Types of Polymorphism


Polymorphism offers one common interface for various executions and for objects to pretend in various manners under various conditions.

C++ supports various kinds of static and dynamic polymorphisms. Compile-time polymorphism does not let for definite run-time decisions, while run-time polymorphism by and large incurs the performance penalization.

 Static Polymorphism

Function overloading permits programs to declare multiple functions having the similar name (merely with various arguments). The functions are differentiated by the forms or number of their formal parametric quantity. In the way indicated, the similar function name could refer to various functions calculating on the context in which it is employed. The type returned by the function is not employed to differentiated overloaded functions and would lead to the compile-time error message.

When declaring the function, the programmer could determine for one or more parametric quantity the default value. Therefore permits the parametric quantity with defaults in an optional manner be excluded when the function is called, in which event the default arguments will be employed. When the function is referred as with more a couple of arguments than there are declared parametric quantity, expressed arguments are matched to parametric quantity in left-to-right order, with any unmatchable parametric quantity at the finish of the parametric quantity list being attributed their default arguments. In many events, determining default arguments in the single function declaration is preferred to rendering overloaded function definitions with various numbers of parametric quantity.

Templates in C++ render the advanced mechanism for composing general, polymorphic code. In peculiar, via the Curiously Recurring Template Pattern, it is possible to carry out the type of static polymorphism that intimately copy the syntax for overriding virtual functions. As C++ templates are Turing-complete and  type-aware, they could also be employed to allow the compiler adjudicate recursive condition and bring forth satisfying programs via template meta programming. In an opposing direction to some belief, template code will not bring forth the majority code after compiling with the proper compiling program settings.

Variable pointers to the base class type in C++ could denoted to objects of any derived classes of that type in add-on to objects incisively matching the variable type. This permits arrays and other types of containers to hold pointers to objects of disagreeing classes. Since appointment of values to variables in general takes place at run-time, this is inevitably the run-time physical procedures.

C++ also renders the dynamic_cast operator, which permits the program to in a safe manner seek conversion of the object into the object of the more particular object type as opposed to conversion to the more general type, which is invariably permitted. This characteristic is based on the run time type information (RTTI). Objects acknowledged to be of the particular type could also be cast to that type with static_cast, the exclusively compile-time construct that is more profligate and does not call for RTTI.

Virtual member functions

Most of the time, when the function in the derived class overrides the function in the base class, the function to call is ascertained by the type of the object. A afforded function is overridden when there subsists no varaition in the type  or number of parametric quantity among two or more definitions of that function. From this time, at compile time, it might not be possible to determine the type of the object and consequently the correct function to call, given only the base class pointer; the decision is consequently put off until run time. This is denoted as  as dynamic dispatch. Virtual member methods  or functions permit the most particular execution of the function to be rcalled, as per the real run-time type of the object. In C++ implementations, this is normally done employing virtual function tables. If  object type is acknowledged,  then this might be got around by add to the beginning the to the full characterized class name before the function call, but in general calls to virtual functions are adjudicated during  run time.


In add-on to standard member functions, operator overloads and destructors could be virtual. A general rule of thumb is that if any functions in the class are virtual, the destructor had better be as well. As the type of the object at its creation is acknowledged at compile time, constructors, and by extension copy constructors, cannot be virtual. Despite anything to the contrary the situation might arise where the copy of the object inevitably to be made when the pointer to the derived object is authorized as the pointer to the base object. In such the event, the common solution is to produce the clone() (or similar) virtual function that produce and returns the copy of the derived class when called.


A member function could also be made "pure virtual" by supplementing it with = 0 after the closing down parenthesis and before the semicolon. A class comprising the pure virtual function is referred as the abstract data type. Objects cannot constituted from abstract data forms an d they could only be deduced from. Any derived class acquires the virtual function as pure and must render the non-pure definition of it prior to objects of the derived class could be produced. A program that endeavors to produce the object of the class with inherited pure virtual member function  or the pure virtual member function is ailment-formed.


Processing  and parsing  C++ source code

It is comparatively hard to compose the good C++ parser with classic parsing algorithms such as LALR. This is partially since the C++ grammar is not LALR. Due to this, there are very few tools for examining or executing non-trivial transformations. For illustration,, refactoring of existent code. A mode to handle this trouble is to select the various syntax. An additional  knock-down parsers, such as GLR parsers, could be considerably simpler although  at a slow tempo.


Parsing  is not the most unmanageable issue in constructing the C++ processing tool. Such tools must also have the same agreement of the entailing the identifiers in the software  program as the compiler might have. Concerned with actual use  systems for actioning C++ must then not only parse the source text, but be able to adjudicate for each identifier exactly which definition employs for illustration, they must  accurate manner handling C++'s complicated  appraising rules and the form as well as types of more prominent expressions.


Finally, the pragmatic C++ processing tool must be capable to address the diversity of C++ dialects employed in exercise (such as that abided by the GNU Compiler Collection and Microsoft's Visual C++) and follow through source code transformers, regenerate source text and set aside analyzers. Put  together boosted parsing algorithms such as program transformation machinery  and GLR with symbol table building could allow the building of absolute C++ tools.


Producing the fairly standards-compliant C++ compiler has demonstrated to be the hard job for compiler vendors in general. For large number of years, various C++ compilers followed through the C++ language to various levels of abidance to  conventions and their followed through altered to a great degree in definite fields such as partial template specialization. New releases of most common C++ compilers affirm nearly all of the C++ 1998 standard.


In order to provide compiler sellers more expectant freedom, the C++ standards committee determined not to prescribe the execution of name mangling,  other execution-particular characteristics comprising exception handling. The negative aspect of the determination is that object code developed by various compilers is gestated to be inappropriate. There were, all the same, endeavors to  conform to standard compilers for exceptional machines or OS, although they appear to be for the most part deserted forthwith.

Exported templates

One peculiar point of argument is the export keyword, proposed to permit template resolutions to be came apart from their declarations. The first  usable compiler to carry out export over a great extent was Comeau C/C++, in early 2003  and in the year 2004, the beta compiler of Borland C++ Builder X was also published. Both of the compilers are established on the EDG C++ front terminal. former compilers such as GCC does not affirm it at all. Beginning ANSI C++ by Ivor Horton renders illustration code with  keyword that will not compose in many compilers, without any reference to this issue. Herb Sutter, former convenor of the C++ standards committee, advocated that export be moved out from succeeding versions of the C++ standard. All the way through the March 2010 ISO C++ standards meeting, the C++ standards committee picked out to move out exported templates altogether from C++0x, but reserve the keyword for succeeding employment.



Polymorphism is the ability to employ the operator or method in various modes. Polymorphism renders various meanings or functions to  methods or operators. Poly, referring to many, stands for the many functions of these operators and methods. A single method usage or the operator functioning in many modes could be referred as polymorphism. Polymorphism denotes to the operations,  objects  or codes that behave  in other manner in the  various contexts.


Polymorphism is the powerful characteristic of the object oriented programming language C++. A single operator + acts other than in various circumstances such as strings, float, integer concerning the conception of polymorphism. The conception contributes to operator overloading. The conception of overloading is also the subdivision of polymorphism. When exiting function or operator operates on the new data type it is overloaded. This characteristic of polymorphism contributes to the conception of virtual methods.


Polymorphism denotes to the capability to call various functions by employing only a type of function call. Expect to be true the developer wants to code vehicles of various shapes such as, rectangles, squares, circles etc. A mode to specify each of these classes is to have the member function for each that makes vehicles of each shape. One more commodious access the programmer could take is to specify the base class named Shape and then create the instance of that class. The programmer could have array that hold pointers to all various objects of the vehicle complied by the simple loop structure to build  vehicle, as per  shape in demand, by enclosing pointers into outlined array. This access contributes to various functions carried out by the similar function call. Polymorphism is employed to give various significances to the similar conception. This is the cornerstone for Virtual function execution.

In polymorphism, the operator functioning or the single function  in various modes is based on  the employment to function the right way. For this to take place, the accompanying considerations must carry out:

ñ  Altogether various classes must be derived from the single base class. For illustration, the shapes of vehicles ( rectangle,  triangle, circle) are from the single base class referred as Shape.

ñ  The member function must be declared as virtual in base class. In the above illustration,  member function for building the vehicle shall be defined as virtual to the base class.


Prominent attribute  and benefits of the conception of Polymorphism:

 Software Program are Easily Extendable:

Once the software program is composed employing the conception of polymorphism, it could in all likelihood be elongated, rendering new objects that adapt to the master interface. It is  not necessary to compose master programs by contributing new forms. Only re-associating is essential to demonstrate the new alterations along with the old software program. This is the most expectant accomplishment of C++ object-oriented programming. In programming language, there has invariably been the demand for bestowing and custom-making. By employing the conception of polymorphism, time and work effort is reduced in add-on to making future sustainment more comfortable.


ñ  Assist in recyclable of code.

ñ  Rendrss more comfortable sustainment of applications.

ñ  Assist in accomplishing validity in applications.


Types of Polymorphism:


C++ renders three various forms of polymorphism.


ñ  Virtual functions

ñ  Function name overloading

ñ  Operator overloading


In add-on to the above given three forms of polymorphism, there subsist other forms of polymorphism:


ñ  Run-time

ñ  Compile-time

ñ  Ad-hoc polymorphism

ñ  Parametric polymorphism


Other forms of polymorphism outlined:


The run-time polymorphism is executed with virtual functions and inheritance.


The compile-time polymorphism is executed with templates.


Ad-hoc polymorphism:


If the range of real forms that could be employed is finite and the alignments must be on an individual basis assigned prior to employ, this is referred as ad-hoc polymorphism.


Parametric polymorphism:

If all code is composed without acknowledgment of any particular type and thus could be employed transparently with any number of new forms it is referred as parametric polymorphism.


In general, there are two main classes of Polymorphism:


ñ  Ad Hoc Polymorphism

ñ  Pure Polymorphism


Overloading concepts fall under the class of Ad Hoc Polymorphism and Virtual methods. Parametric and Templates classes lie under the class of Pure Polymorphism.


In C++ they in general mean the thing of employing the derived class via the base class pointer or reference, which is referred as subtype polymorphism. But they often forget that there are all kinds of other polymorphisms in C++, such as parametric polymorphism, ad-hoc polymorphism and coercion polymorphism.


These polymorphisms also go by various names in C++ are :

ñ  Subtype polymorphism is also referred as run time polymorphism.

ñ  Parametric polymorphism is also referred as compile-time polymorphism.

ñ  Ad-hoc polymorphism is also referred as overloading.

ñ  Coercion is also referred as (implicit or explicit) casting.


Subtype Polymorphism (Run time Polymorphism)


Subtype polymorphism is what everyone interprets when they say "polymorphism" in C++. It's the ability to employ derived classes via base class pointers and references. 

Parametric Polymorphism (Compile-Time Polymorphism)


Parametric polymorphism renders the means to execute the similar code for any type. In C++ parametric polymorphism is implemented via templates.


Ad-hoc Polymorphism (Overloading)

Ad-hoc polymorphism permits functions with the similar name act differently for each type. For illustration, given two ints and the + operator, it adds them together. Provided two std::strings it adds them together. This is denoted as overloading.

Coercion Polymorphism (Casting)

Coercion happens when the object or the primitive is cast into some  other object type or primitive type

Students can get solutions for Polymorphism in C++  online. ExpertsMinds interactive academic session will make learning  Polymorphism in C++ easy. Get answers online to all the questions, assignments, homework on Polymorphism in C++ , under the expert guidance of our tutors. Expertsmind.com offers Polymorphism in C++ online tutoring service,  Polymorphism in C++ homework help and Polymorphism in C++ anytime from anywhere 24x7.