dynamic-binding

In C++, during dynamic binding, consider the following example... class Base { virtual void fun() { cout<<"Base"; } }; class Derived : Base { void fun() { cout<<"Derived"; } }; int main() { Base *bptr; Derived d; bptr=&d; bptr->fun(); } The output of the above function is "Derived" due to the declaration of virtual keyword/dynamic binding. As per my understanding, a virtual table (Vtable) would be created which contains the address of the virtual functions. In this case the virtual table created for the derived class points to the inherited virtual fun() . And bptr->fun() will be getting

I'm trying to get an ASP.NET 3.5 GridView to show a selected value as string when being displayed, and to show a DropDownList to allow me to pick a value from a given list of options when being edited. Seems simple enough? My gridview looks like this (simplified): <asp:GridView ID="grvSecondaryLocations" runat="server" DataKeyNames="ID" OnInit="grvSecondaryLocations_Init" OnRowCommand="grvSecondaryLocations_RowCommand" OnRowCancelingEdit="grvSecondaryLocations_RowCancelingEdit" OnRowDeleting="grvSecondaryLocations_RowDeleting" OnRowEditing="grvSecondaryLocations_RowEditing" OnRowUpdating=

I am really confused about dynamic binding and static binding. I have read that determining the type of an object at compile time is called static binding and determining it at runtime is called dynamic binding. What happens in the code below: Static binding or dynamic binding? What kind of polymorphism does this show? class Animal { void eat() { System.out.println("Animal is eating"); } } class Dog extends Animal { void eat() { System.out.println("Dog is eating"); } } public static void main(String args[]) { Animal a=new Animal(); a.eat(); } Your example is dynamic binding , because at run

I'm currently doing an assignment for one of my classes, and in it, I have to give examples, using Java syntax, of static and dynamic binding . I understand the basic concept, that static binding happens at compile time and dynamic binding happens at runtime, but I can't figure out how they actually work specifically. I found an example of static binding online that gives this example: public static void callEat(Animal animal) { System.out.println("Animal is eating"); } public static void callEat(Dog dog) { System.out.println("Dog is eating"); } public static void main(String args[]) { Animal

What is the difference between early and late binding? The short answer is that early (or static) binding refers to compile time binding and late (or dynamic) binding refers to runtime binding (for example when you use reflection). James A. Rosen In compiled languages, the difference is stark. Java: //early binding: public create_a_foo(*args) { return new Foo(args) } my_foo = create_a_foo(); //late binding: public create_something(Class klass, *args) { klass.new_instance(args) } my_foo = create_something(Foo); In the first example, the compiler can do all sorts of neat stuff at compile time.

Yesterday I had a two-hour technical phone interview (which I passed, woohoo!), but I completely muffed up the following question regarding dynamic binding in Java. And it's doubly puzzling because I used to teach this concept to undergraduates when I was a TA a few years ago, so the prospect that I gave them misinformation is a little disturbing... Here's the problem I was given: /* What is the output of the following program? */ public class Test { public boolean equals( Test other ) { System.out.println( "Inside of Test.equals" ); return false; } public static void main( String [] args ) {