Bilgisayar programlamada **dinamik iletim**, altyordam çağrılarının ilişkin altyordam başlangıç adresine dinamik olarak bağlanmasıdır. Bir diğer deyişle, dinamik iletim program metnindeki bir çağrı ile işletilen altyordamın programın çalışması sırasında birbirine bağlanması durumudur. Geri çağrı ve çokbiçimliliğin realize edilmesinde kullanılan bu bağlama yöntemi, yordamsal programlama dillerinde altyordam göstericileriyle gerçekleştirilirken, nesne yönelimli dillerde kalıtlama ve gerçekleştirme ilişkilerinin kullanılmasıyla otomatikman sağlanır. Altyordamların birinci sınıf dil öğesi olarak ele alındığı fonksiyonel programlama dillerinde ise, aynı işlevsellik altyordamların argüman olarak geçirilmesi ile sağlanabilir.

Dinamik İletim ve Diğer Kavramlar
---------------------------------

Dinamik iletimin başlıca amacı, kullanıcının gereksinimlerine göre değişkenlik gösterebilecek kod parçalarının kullanıcı tarafından tamamlanmasını mümkün kılarak yazılım çerçevelerinin çokbiçimli kullanılabilmesini sağlamak ve böylece daha yüksek yeniden kullanım elde etmektir. Örnek olarak, görsel arayüzlü bir yazılımı kullanırken yaptıklarınızı düşünün, düğmelere basıyorsunuz, metin kutularını dolduruyorsunuz, listelerden seçimler yapıyorsunuz, vs. Ancak, düğmenin (ve diğer görsel öğelerin) davranışı temelde değişmediği halde, düğmeye basıldığında programın amacına dönük şeyler oluyor. Mesela, öğrenci kayıt formunun doldurulması sonrasında tıklanan Tamam düğmesi öğrenci kaydını yaparken, kitap alışverişi sitesindeki aynı görünüşlü düğmeyi tıklamanız kitapların evinize kadar gelmesini sağlayan bir sürecin başlamasına neden oluyor. Tıklamak eylemi aynıyken, olup biten değişiyor ve bunun görsel arayüz kitaplığını üreten firma tarafından bilinmesi olanaksız; resmin sizin kullandığınız yazılımı—öğrenci kayıt ve kitap alışveriş yazılımları—üretenler tarafından doldurulması gerekli. İşte bu, yordamsal programlama dillerinde altyordam göstericilerine uygun altyordamların adreslerini geçirerek sağlanırken, nesne yönelimli dillerde yazılım çerçevesince sağlanan üstsınıflardan kalıtlama veya arayüzleri gerçekleştirme ile sağlanabilir.

Üstsınıftan kalıtlama veya arayüz gerçekleştirme senaryosunun geçerli olduğu durumlarda, bir nesneye gönderilen ileti sonucunda hangi metodun çağrılacağını belirleyen aşağıdaki adımların akılda tutulması yararlı olacaktır.

1. İletinin uygunluğu tutacak—gösterici veya referans da olabilir—türünün (statik tür) desteklediği iletilerle denetlenir. Derleme sırasında yapılan bu denetim, ileti ve metot imzalarının uyuşup uyuşmadığına bakar. Uyuşmanın olmaması durumunda, derleme hata mesajı vererek başarısız bir biçimde sona erecek ve bir sonraki adıma geçilmeyecektir.
2. Tutacağın temsil ettiği nesnenin sınıfına (dinamik tür) bakarak hangi metodun çağrılacağına karar verilir. Bu karar, nesnenin sınıfında gerçekleştirilen veya üstsınıflardan kalıtlanan metotlardan biri seçilerek programın çalışması sırasında verilir.

Programlama Dilleri ve Dinamik İletim
-------------------------------------

### C

Kabarcık sıralaması algoritmasının C programlama dilindeki soysal gerçekleştirimini içeren aşağıdaki `kabarcik_siralama` fonksiyonunun imzasında iki nokta dikkat çekiyor: fonksiyon göstericisi ve eleman türü olarak `void*` ile eşanlamlı ilan edilmiş olan `Object`. Bunlardan ilki dizinin eleman türüne ve/veya sıralama fonksiyonunun kullanılış bağlamına göre farklı biçimlerde sıralanmasını olanaklı kılarken, ikincisi dizinin herhangi bir türden eleman tutabilmesini—yani, dizinin soysal olmasını—sağlıyor.

Kabarcik.h

```
#ifndef KABARCIK\_H
#define KABARCIK\_H

typedef void\* Object;
typedef int (\*KARSILASTIRMA\_FONK)(Object, Object);

extern void kabarcik\_siralama(Object dizi[], int boy, KARSILASTIRMA\_FONK kar\_fonk);
#endif

```

Yukarıda sağlanan imzaya uygun gerçekleştirime göz atıldığında ise, işin püf noktasının fonksiyon göstericisinin kullanıldığı içteki döngünün ilk satırında olduğu görülür. Her ne kadar `kar` adındaki bir fonksiyonun çağrılması ile aynı görünse de, aslında bu satırda `kar` adlı fonksiyon göstericisinin sahip olduğu değerin işaret ettiği bellek konumunda başlayan bir fonksiyon çağrılmaktadır; `kabarcik_siralama` fonksiyonunun çağrıldığı noktalarda `kar` parametresine değişik değerlere sahip göstericilerin geçirilmesi, farklı karşılaştırma ölçütlerinin kullanılması ve dolayısıyla sıralamanın farklı türler ve/veya biçimlerde yapılması anlamına gelecektir.

Kabarcik.c

```
#include <stdio.h>
#include "Kabarcik.h"

#define BOOL char
#define FALSE 0
#define TRUE 1

static void takas\_et(Object dz[], int sol\_indis, int sag\_indis) {
 Object gecici = dz[sol\_indis];
 dz[sol\_indis] = dz[sag\_indis];
 dz[sag\_indis] = gecici;
} /\* void takas\_et(Object[], int, int) sonu \*/

void kabarcik\_siralama(Object dz[], int boy, KARSILASTIRMA\_FONK kar) {
 int gecis, j;

 for(gecis = 1; gecis < boy; gecis++) {
 BOOL takas\_var = FALSE;

 for (j = 0; j < boy - gecis; j++)
 if (kar(dz[j], dz[j + 1]) > 0) { 
 takas\_et(dz, j, j + 1);
 takas\_var = TRUE;
 } /\* if sonu \*/
 if (!takas\_var) return; 
 } /\* for(gecis = 1; gecis < boy; gecis++) sonu \*/
} /\* void kabarcik\_siralama(Object[], int, KARSILASTIRMA\_FONK) sonu \*/

```

Aşağıda sağlanan sınama programının incelenmesi olup bitenin daha iyi anlaşılmasını sağlayacaktır. `kabarcik_siralama` fonksiyonunun ilk kullanılışı `Integer` türlü elemanları olan bir diziyi karşılaştırma amacıyla `int_kars` fonksiyonundan yararlanarak sıralarken, ikinci kullanılış komut satırında geçirilen karakter katarı dizisini karşılaştırmak için `karakter_katarı_kars` fonksiyonundan yararlanarak sıralıyor.

Kabarcik\_Sinama.c

```
#include <stdio.h>
#include <string.h>
#include "Kabarcik.h"

typedef int\* Integer;

void ksa\_bas(char \*ksa[], int boy) { ... }

void intleri\_bas(Integer dz[], int boy) { ... }

int karakter\_katar\_kars(Object sol, Object sag) {
 return(strcmp((char\*) sol, (char \*) sag));
} /\* int karakter\_katar\_kars(Object, Object) sonu \*/

int int\_kars(Object sol, Object sag) {
 Integer ig1 = (Integer) sol;
 Integer ig2 = (Integer) sag;

 if (\*ig1 > \*ig2) return 1;
 else if (\*ig1 < \*ig2) return -1;
 else return 0; 
} /\* int int\_kars(Object, Object) sonu \*/

int main(int args, char \*ksa[]) {
 int dizi[] = {1, 3, 102, 6, 34, 12, 35}, i;
 Integer int\_dz[7];
 for (i = 0; i < 7; i++) int\_dz[i] = &dizi[i];

 printf("\nTAMSAYI DIZISI SINANIYOR\n\nSiralama oncesi\n"); 
 intleri\_bas(int\_dz, 7); 
 kabarcik\_siralama((Object\*) int\_dz, 7, &int\_kars); 
 printf("\nSiralama sonrasi\n"); intleri\_bas(int\_dz, 7);
 
 printf("\nKARAKTER KATARI DIZISI SINANIYOR\n\nSiralama oncesi\n"); 
 ksa\_bas(&ksa[1], args - 1);
 kabarcik\_siralama((Object\*) &ksa[1], args - 1, karakter\_katari\_kars);
 printf("Siralama sonrasi\n"); ksa\_bas(&ksa[1], args - 1);

 return(0);
} /\* int main(int, char \*\*) sonu \*/

```

### C++

C'nin nesne yönelimli ardılı olan C++'da dinamik iletim, fonksiyon göstericilerine ek olarak, üstsınıfta `**virtual**` ilan edilen bir fonksiyonun altsınıflarda ihtiyaca uygun bir biçimde gerçekleştirilmesi veya ezilmesi ile sağlanır. Varsayılan iletim biçiminin statik olması nedeniyle, söz konusu fonksiyonun `**virtual**` ilan edilmemesi dinamik iletimi ve dolayısıyla çokbiçimliliği engelleyecektir. Unutulmaması gereken bir diğer nokta, çokbiçimliliğin üstsınıf türünden bir gösterici veya referans—bir başka deyişle, derleyici tarafından özel bir biçimde ele alınan sabit gösterici—ile mümkün olduğudur. Bu, üstsınıf ve altsınıf nesnelerinin muhtemelen değişik büyüklüklerde olması, büyüklüğü çalışma anında belirlenebilen bellek bölgelerinin yığın bellekten ayrılması gerekliliği ve yığın belleğin ancak göstericiler ile işlenebilmesi nedeniyle zorunludur.

Memur.hxx

```
#ifndef MEMUR\_HXX
#define MEMUR\_HXX
class Memur {
...
public:
 virtual double aylik\_gelir() = 0;
...
}; // Memur sinifinin sonu
#endif

```

İkinci aşamada yapılması gereken, dinamik iletimli çağrılacağı için `**virtual**` ilan edilmiş olan fonksiyonların altsınıflarda tanımlanmakta olan türlerin özelliklerini göz önünde bulundurarak gerçekleştirmektir.

GenelMudur.hxx

```
#ifndef GENELMUDUR\_HXX
#define GENELMUDUR\_HXX
#include "Memur.hxx"

class GenelMudur : public Memur { ... };
#endif

```

GenelMudur.c

```
#include "GenelMudur.hxx"
...
double GenelMudur::aylik\_gelir() {
 // Geliri derece, kademe ve alınabilecek rüşveti hesaba katarak hesapla.
} // double GenelMudur::aylik\_gelir() sonu
...

```

DuzMemur.hxx

```
#ifndef DUZMEMUR\_HXX
#define DUZMEMUR\_HXX
#include "Memur.hxx"

class DuzMemur : public Memur { ... };
#endif

```

DuzMemur.c

```
#include "DuzMemur.hxx"
...
double DuzMemur::aylik\_gelir() {
 // Geliri derece ve kademeden yararlanarak hesapla.
} // double DuzMemur::aylik\_gelir() sonu
...

```

Dinamik iletimli fonksiyonun çokbiçimli kullanımına bir örnek aşağıdaki kod parçasından görülebilir. Dikkat edilecek olursa, `memurlar` adındaki kabın eleman türü üstsınıfın referans türüne sahip tanımlanmış. Dolayısıyla, söz konusu kap `Memur` veya `Memur` gibi olan—yani, `Memur`'dan kalıtlayan—herhangi bir türden nesneyi gösteren referanslar tutacaktır.

Bordro.cpp

```
#include <vector>
using namespace std;
#include "Memur.hxx"
#include "GenelMudur.hxx"
#include "DuzMemur.hxx"

int main(void) {
 vector<Memur&> memurlar;
 ...
 double toplam\_odeme = 0;
 vector<Memur&>::const\_iterator bas = memurlar.begin(), son = memurlar.end();
 while(bas != son) {
 toplam\_odeme += (\*bas).aylik\_gelir();
 bas++;
 } // while (bas != son) sonu
 ...
} // int main(void) sonu

```

### Java

Java'da, `**final**` ilan edilerek aksi söylenmedikçe, tüm metotlar dinamik iletimle çağrılır. Dolayısıyla, programcının fazladan bir şey yapmasına gerek yoktur.

#### Kalıtlama Yoluyla Çokbiçimlilik ve Dinamik İletim

Memur.java

```
public abstract class Memur {
 ...
 public double gelir();
 ...
} // Memur sınıfının sonu

```

GenelMüdür.java

```
public class GenelMüdür extends Memur {
 ...
 public double gelir() {
 // Geliri derece, kademe ve alınabilecek rüşveti hesaba katarak hesapla.
 }
 ...
} // GenelMüdür sınıfının sonu

```

DüzMemur.java

```
public class DüzMemur extends Memur {
 ...
 public double gelir() {
 // Geliri derece ve kademeden yararlanarak hesapla.
 }
 ...
} // DüzMemur sınıfının sonu

```

Kalıtlama yoluyla çokbiçimliliğin örneklendiği aşağıdaki kod parçasından da görülebileceği gibi, gönderilen ileti sonucunda çağrılan metot, tutacağın arkasındaki nesnenin türüne göre belirlenmektedir. Buna göre, `**for**` döngüsünün içindeki `gelir` iletisi, kimi zaman `GenelMüdür` kimi zamansa `DüzMemur` sınıfındaki aynı imzalı metodun çağrılmasına neden olacaktır.

Bordro.java

```
import java.util.Vector;

public class Bordro {
 Vector<Memur> çalışanlar = new Vector<Memur>();
 ...
 double toplamÖdeme = 0;
 for (Memur çalışan : çalışanlar)
 toplamÖdeme += çalışan.gelir();
 ...
} // Bordro sınıfının sonu

```

#### Gerçekleştirme Yoluyla Çokbiçimlilik ve Dinamik İletim

Java, türleri (sınıflar ve arayüzler) *gibi olmak* ilişkisine göre bir sıradüzenine koyan kalıtlama ilişkisinin yanı sıra sınıfları sahip oldukları ortak arayüzlere göre kategorize eden gerçekleştirme ilişkisini de sunar. Gerçekleştirme ilişkisi yoluyla dinamik iletimin kullanılması ve metotların çokbiçimli bir şekilde kullanılması, birbirleriyle benzer olsun veya olmasın, aynı kategoriye giren sınıfların ortak bir arayüzü gerçekleştirmesi ile mümkün olur.

Öğrenci.java

```
package öğrenciişleri;

public class Öğrenci implements Comparable<Öğrenci>{
 ...
 pubic int compareTo(Öğrenci sağ) { ... }
 ...
} // Öğrenci sınıfının sonu

```

Vatandaş.java

```
package gelirvergisi;

public class Vatandaş implements Comparable<Vatandaş>{
 ...
 public int compareTo(Vatandaş sağ) { ... }
 ...
} // Vatandaş sınıfının sonu

```

Algoritmalar.java

```
package algoritmalar;

import java.util.\*;

public class Sıralamalar {
 ...
 public static <V extends Comparable<? extends V>> void kabarcık(List<V> kap) {
 if (kap.length <= 1) return;

 boolean takasVar = false;
 int geçiş = 1;
 do {
 takasVar = false;
 for (int j = 0; j < kap.length - geçiş; j++) {
 V oAnki = kap.get(j), sonraki = kap.get(j + 1);
 if (oAnki.compareTo(sonraki) > 0) {
 V geçici = oAnki;
 oAnki = sonraki;
 sonraki = geçici;
 takasVar = true;
 } // if (oAnki.compareTo(sonraki) > 0) sonu
 } // for (int j = 0; j < kap.length - geçiş; j++) sonu
 } while(++geçiş < kap.length && takasVar);
 } // <V extends Comparable<V>> void kabarcık(List<V>) sonu
 ...
} // Sıralamalar sınıfının sonu

```

AlgoritmaSınama.java

```
import gelirvergisi;
import öğrenciişleri;
import static algoritmalar.Sıralamalar;

public class AlgoritmaSınama {
 ...
 kabarcık(öğrenciler);
 ...
 kabarcık(vergiMükellefleri);
 ...
} // AlgoritmaSınama sınıfının sonu

```

### Scheme

Fonksiyonel programlama dillerinden olan Scheme'de dinamik iletim, altyordamların birinci sınıf muamele görmesi nedeniyle oldukça kolay sağlanır. Altyordam türlerinin varlığı, altyordamların argüman olarak geçirilmesini ve altyordamlardan sonuç olarak döndürülmesini olanaklı kılar. Bunun sonucunda, çokbiçimli davranması beklenen altyordama değişik altyordamların geçirilmesi işimizi görecektir. Örneğin, aşağıdaki kabarcık sıralaması gerçekleştirimine ikinci argüman olarak `>` geçirilmesi ilk argümandaki sayı dizisinin artan sırada sıralanması sağlarken, `string-<` geçirilmesi ilk argümandaki karakter katarı dizisinin azalan sırada sıralanmasını sağlayacaktır.

```
(define (kabarcık-alg dz öncemi?)
 (define (eleman-takas dz i j)
 (let ([geçici (vector-ref dz i)])
 (vector-set! dz i (vector-ref dz j))
 (vector-set! dz j geçici)))
 (define (geçiş ub)
 (do ((i 0 (+ i 1)) (takas? #f)) 
 ((= i (- ub 1)) takas?)
 (when (öncemi? (vector-ref dz (+ i 1)) (vector-ref dz i))
 (eleman-takas dz i (+ i 1))
 (set! takas? #t))))
 
 (do ((j (vector-length dz) (- j 1)) 
 (takas? #t (geçiş j))) 
 ((or (not takas?) (= j 1)) dz)))

```

Notlar
------

1. ↑  Adres işlecinin (`&`) kullanımlardan birinde olup diğerinde olmaması sizi şaşırtmasın. Her iki durumda da geçirilen değer, söz konusu fonksiyonun başlangıç adresini işaret eden bir gösterici değeri olacaktır.
2. ↑  Gerçekleştirimi sağlanmayan dinamik iletimli bir fonksiyonunun bulunması, `Memur` sınıfını bir soyut sınıf (İngilizce: abstract class) yapıyor. Dolayısıyla, kabımız içindeki referansların `Memur` nesnelerini göstermesi, soyut bir sınıfın nesneleri yaratılamayacağı için, söz konusu olmayacaktır.

Ayrıca bakınız
--------------

* Çokbiçimlilik
* Dinamik bağlama
* Gerçekleştirme ilişkisi
* Geri çağrı
* Kalıtlama ilişkisi

Dış bağlantılar
---------------

* Geri çağrı (İngilizce) 6 Mayıs 2011 tarihinde Wayback Machine sitesinde arşivlendi.
* Havaleciler: .NET'te tür güvenlikli geri çağrılar (İngilizce) 11 Aralık 2011 tarihinde Wayback Machine sitesinde arşivlendi.
* Dinamik iletim (İngilizce) 31 Mart 2011 tarihinde Wayback Machine sitesinde arşivlendi.
* Dinamik iletimli fonksiyonlar (İngilizce)2 Ekim 2011 tarihinde Wayback Machine sitesinde arşivlendi.