¿Dynamisk bindning, polymorfism (c++)?

Om man deklarerar en funktion som virtuell tillåter man att underklassers eventuella egna implementationer av funktionen alltid körs istället för basklassens; även om man till exempel konverterar en underklasspekare till basklassens typ innan anropet görs.

class A
{
public:
	void fkn1()
	{
		cout << "A1" << endl;
	}

	virtual void fkn2()
	{
		cout << "A2" << endl;
	}
};

class B: public A
{
public:
	void fkn1()
	{
		cout << "B1" << endl;
	}

	void fkn2()
	{
		cout << "B2" << endl;
	}
};

///////////
	A* a1 = new A();
	a1->fkn1(); //inga konstigheter; ger "A1"
	a1->fkn2(); // "A2"

	B* b1 = new B(); 
	b1->fkn1(); // "B1"
	b1->fkn2(); // "B2"

	A* q = b1;
	q->fkn1(); // Här kommer dock A::fkn1() anropas, då q är av typen A* (trots att objektet "egentligen" är av typen B), och resultera i "A1"
	q->fkn2(); // "virtual" löser "problemet": "B2"
///////////

Polymorphism tillämpas när du använder dig av en pekare av basklasstyp för att peka på något objekt som ärver från basklassen. T.ex. om du har basklassen Animal så kan du skapa subklassen Kanin som ärver från Animal. Eftersom att Kanin är en subklass och Animal är en basklass är det möjligt att använda sig av en pekare av basklasstypen (Animal) för att peka på ett subklass-objekt (Kanin).

Den dynamiska bindningen kommer alltså in, som ovanstående skriver, när man vill komma åt specifika funktioner men även överskuggade funktioner som finns hos subklassen. Som inte är definierade som virtual i basklassen. Har man då alltså en Animal-pekare och ett Kanin-objekt, och försöker kalla på funktioner så kommer du endast åt de funktioner som finns hos basklassen (Animal). Vilket gör att även om man har överskuggat en funktion hos Kanin som ärvdes från Animal som kommer den grundform som finns i Animal köras, trots att det är ett Kanin-objekt.

För att förhindra det här, använder mig sig alltså av dynamisk bindning och byter pekartyp under programkörning. I C++ använder man då dynamic_cast som tillfälligt kastar objektet till en pekare av samma typ. Vilket gör det möjligt att använda subklassens egna funktioner.