difference between compile time and runtime polymorphisms

Overridden functions are functions that have the same signature, but are implemented in different derived classes. At compile time, usually the base class type is used to reference an object, though at run time this object could be of a derived type, so when an overridden method is called, the implementation that is called is dependent on what kind of object is doing the calling (base vs. a derived type) which is unknown at compile time. Overloading (not really polymorphism) is simply multiple functions which have the same name but different signatures (think multiple constructors for an object taking different numbers of arguments). Which method is called is known at compile time, because the arguments are specified at this time.

Polymorphism is defined as one interface to control access to a general class of actions. There are two types of polymorphism one is compile time polymorphism and the other is run time polymorphism. Compile time polymorphism is functions and operators overloading. Runtime time polymorphism is done using inheritance and virtual functions.

Polymorphism means that functions assume different forms at different times. In case of compile time it is called function overloading. For example, a program can consist of two functions where one can perform integer addition and other can perform addition of floating point numbers but the name of the functions can be same such as add. The function add() is said to be overloaded. Two or more functions can have same name but their parameter list should be different either in terms of parameters or their data types. The functions which differ only in their return types cannot be overloaded. The compiler will select the right function depending on the type of parameters passed. In cases of classes constructors could be overloaded as there can be both initialized and uninitialized objects. Here is a program which illustrates the working of compile time function overloading and constructor overloading.
eg.

namespace CommonClasses {     public interface IAnimal     {         string Name { get; }         string Talk();     } }   // Assembly: Animals using System; using CommonClasses;   namespace Animals {     public abstract class AnimalBase     {         public string Name { get; private set; }           protected AnimalBase(string name) {             Name = name;         }     }       public class Cat : AnimalBase, IAnimal     {         public Cat(string name) : base(name) {         }           public string Talk() {             return "Meowww!";         }     }       public class Dog : AnimalBase, IAnimal     {         public Dog(string name) : base(name) {                     }           public string Talk() {             return "Arf! Arf!";         }     } }   // Assembly: Program // References and Uses Assemblies: Common Classes, Animals using System; using System.Collections.Generic; using Animals; using CommonClasses;   namespace Program {     public class TestAnimals     {         // prints the following:         //   Missy: Meowww!         //   Mr. Bojangles: Meowww!         //   Lassie: Arf! Arf!         //         public static void Main(string[] args)         {             var animals = new List() {                 new Cat("Missy"),                 new Cat("Mr. Bojangles"),                 new Dog("Lassie")             };               foreach (var animal in animals) {                 Console.WriteLine(animal.Name + ": " + animal.Talk());             }         }     } }

//Taken from a blog at Wiki Answers.Found it easy to follow.

3 Replies

Know the answer? Post it — somebody with the same question will find it here.

Sanjeeb Lenka13y ago
Refer to this link for details

http://www.c-sharpcorner.com/uploadfile/puranindia/polymorphism-in-C-Sharp/
Akhil Mittal13y ago
Overridden functions are functions that have the same signature, but are implemented in different derived classes. At compile time, usually the base class type is used to reference an object, though at run time this object could be of a derived type, so when an overridden method is called, the implementation that is called is dependent on what kind of object is doing the calling (base vs. a derived type) which is unknown at compile time. Overloading (not really polymorphism) is simply multiple functions which have the same name but different signatures (think multiple constructors for an object taking different numbers of arguments). Which method is called is known at compile time, because the arguments are specified at this time.

Akhil Mittal13y ago