Compile time polymorphism vs. run time polymorphism

Why is overloading called compile time polymorphism and Overriding run time polymorphism in C开发者_运维知识库#?

Well, overloading decisions (which method signatures are used, based on the arguments¹) are made by the compiler, whereas overriding decisions (which method implementations are used, based on the type of the target of the method) are made by the CLR at execution time.

I wouldn't usually call overloading "polymorphism" though. In my experience the word usually refers to overriding. I suppose overloading does allow you to treat an object of one type as another, although overloading itself doesn't need to be involved there - it's just normal type conversions.

Here's an example showing that overload choice is performed at compile time:

using System;

class Test
{
    static void Foo(object a)
    {
        Console.WriteLine("Object overload called");
    }

    static void Foo(string a)
    {
        Console.WriteLine("String overload called");
    }

    static void Main()
    {
        object x = "hello";
        Foo(x);
    }
}

Here the Foo(object) overload is called because x is of type object at compile time - it's only at execution time that it's known to refer to a string.

Compare that with this example:

using System;

class Base
{
    public virtual void Foo()
    {
        Console.WriteLine("Base.Foo called");
    }
}

class Derived : Base
{
    public override void Foo()
    {
        Console.WriteLine("Derived.Foo called");
    }
}

class Test
{
    static void Main()
    {
        Base x = new Derived();
        x.Foo();
    }
}

Here the compile-time type of x is Base, but it's still the derived class's overriding method which is called, because the execution-time type of the object that x refers to is Derived.

¹ It's slightly more complicated than that in fact, due to method hiding etc - but in simple cases you can think of it as just picking the signature.

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

Through inheritance, a class can be used as more than one type; it can be used as its own type, any base types, or any interface type if it implements interfaces. This is called polymorphism.

Polymorphism means having more than one form. Overloading and overriding are used to implement polymorphism. Polymorphism is classified into compile time polymorphism or early binding or static binding and Runtime polymorphism or late binding or dynamic binding.

Overriding - same method names with same arguments and same return types associated in a class and its subclass. Overriding in C# makes use of the "override" keyword. To override a method means to replace it with a new way of handling data.

Overloading - same method name with different arguments, may or may not be same return type written in the same class itself.

Compile time Polymorphism or Early Binding

The polymorphism in which compiler identifies which polymorphic form it has to execute at compile time it self is called as compile time polymorphism or early binding.

Advantage of early binding is execution will be fast. Because every thing about the method is known to compiler during compilation it self and disadvantage is lack of flexibility.

Examples of early binding are overloaded methods, overloaded operators and overridden methods that are called directly by using derived objects.

Runtime Polymorphism or Late Binding

The polymorphism in which compiler identifies which polymorphic form to execute at runtime but not at compile time is called as runtime polymorphism or late binding.

Advantage of late binding is flexibility and disadvantage is execution will be slow as compiler has to get the information about the method to execute at runtime.

Example of late binding is overridden methods that are called using base class object.

 class A
 {
    public virtual void Leg(string Name)
    {

    }
 }

 class B:A
 {
    public override void Leg(string Name)
    {

    }
 }

Example for Over loading

 class A
 {
  void a()
   {
   }
  void a(string Name)
   {
   }
 }

In other words, "Many forms of a single object is called Polymorphism."

Eg:

A Team Leader behaves to Sub Ordinate. A Team Leader behaves to his/her seniors. A Team Leader behaves to other Team Leaders.

Here Team Leader is an object but attitude is different in different situation.

Difference between Method Overriding and Method hiding

Method overriding allows a subclass to provide a specific implementation of a method that is already provided by base class. The implementation in the subclass overrides (replaces) the implementation in the base class. The important thing to remember about overriding is that the method that is doing the overriding is related to the method in the base class. When a virtual method is called on a reference, the actual type of the object to which the reference refers is used to determine which method implementation should be used. When a method of a base class is overridden in a derived class (subclass), the version defined in the derived class is used. This is so even should the calling application be unaware that the object is an instance of the derived class.

Method hiding does not have a relationship between the methods in the base class and derived class. The method in the derived class hides the method in the base class.

compile time polymorphism

Suppose lets say you have 2 methods as follows; since the method shares same name but have different parameters; it is called as "overloaded" method. Eat(string food); Eat(string food, string SpoonOrFork);

and you are using like this in your dinner class

public class Man
{
 public bool Eat (string food)
 {
  //implementation
 }

 public bool Eat (string food, string SpoonOrFork)
 {
  //implementation
 }

}
public class dinner
{
  public bool Start()
  {
   string food = "course1";
   Man.Eat ( food);
  }
}

Now when you compile this program the compiler knows exactly which version of Eat method to call during compile time itself (because of the difference in parameters).

That's why it is called as compile time polymorphism.

Run time polymorphism

public class chimp
    {
        public virtual void walk()
        {
            Console.WriteLine("I am walking using 4 legs");
        }

    }

    public class neanderthals : chimp
    {
        public override void walk()
        {
            Console.WriteLine("I am walking using 2 legs");
        }

    }



    class Program
    {
        static void Main(string[] args)
        {
            chimp x = new neanderthals();
            x.walk();
            Console.ReadLine(); // this will give an output of "I am walking using 2 legs"
        }
    }

In the above code x is of type chimp. Even though the compiler thinks it is going to call the walk method in chimp; but that is not what actually happens. Since it depends on CLR (run time) this kind of polymorphism is called "run-time" polymorphism.

Polymorphism

Polymorphism means many forms (ability to take more than one form). In Polymorphism poly means “multiple” and morph means “forms” so polymorphism means many forms.

In polymorphism we will declare methods with same name and different parameters in same class or methods with same name and same parameters in different classes. Polymorphism has ability to provide different implementation of methods that are implemented with same name.

In Polymorphism we have 2 different types those are

 -  Compile Time Polymorphism (Called as Early Binding or Overloading or static binding)

 -  Run Time Polymorphism (Called as Late Binding or Overriding or dynamic binding)

Compile Time Polymorphism

Compile time polymorphism means we will declare methods with same name but different signatures because of this we will perform different tasks with same method name. This compile time polymorphism also called as early binding or method overloading.

Method Overloading or compile time polymorphism means same method names with different signatures (different parameters)

For more details check this link polymorphism in c#

Run Time Polymorphism

Run time polymorphism also called as late binding or method overriding or dynamic polymorphism. Run time polymorphism or method overriding means same method names with same signatures.

In this run time polymorphism or method overriding we can override a method in base class by creating similar function in derived class this can be achieved by using inheritance principle and using “virtual & override” keywords.

Compile time Polymorphism

Compile time Polymorphism is also known as method overloading. Method overloading means having two or more methods with the same name but with different signatures.

Run time Polymorphism

Run time Polymorphism is also known as method overriding. Method overriding means having two or more methods with the same name and same signature, but with a different implementation

Run time Polymorphism Example in c#.

using System;
public class demo{
public static void Main(String[] args){

cal cal ;

add a = new add();
cal = a;
Console.WriteLine("Addition is" + cal.calculate(20, 20));   

sub s = new sub();
cal = s;
Console.WriteLine("Substraction is" + cal.calculate(20, 20));

mul m = new mul();
cal = m;
Console.WriteLine("Multiplication is" + cal.calculate(20, 20));


div d = new div();
cal = d;
Console.WriteLine("Division is" + cal.calculate(20, 20));

Console.ReadLine();
}
}

public abstract class cal{
       public abstract int calculate(int a, int b);
}


public class add : cal {
      public override int calculate(int a ,int b){
        return a+b;
      }
 }

public class sub : cal{
      public override int calculate(int a, int b){
        return a-b;
      }     
}

public class mul : cal{
      public override int calculate(int a, int b){
        return a*b;
      }
 }

 public class div : cal{
       public override int calculate(int a, int b){
            return a/b;
       }
 }

Because it's known at compile time which of your overloaded functions is called, but that is not always the case for an overridden function.

Classical examples of static polimorphism are based on template metaprogramming or Duck Typing but not on method overloading.

Static polimorphism means that desicion is made by compilier (statically), and dynamic polimorphism means that desition is made only in runtime (dynamically).