Çok kısaca... :)

Yalnızca dizi ve bağlı liste topluluklarını ele alalım. Belirli numaralı bir dizi elemanına erişim için [] işleci kullanılır. Bağlı listede ise başından o numaraya kadar ilerlemek gerekir.

Algoritma olarak da "şu aralıktaki elemanları rastgele karıştır" anlamına gelen karıştır diye bir algoritma düşünelim.

Erişici diye bir kavram olmasa, ancak bütün topluluğu karıştırabiliriz. Ek olarak, dizi karıştırma ve bağlı liste karıştırma algoritmalarını farklı farklı yazmak zorunda kalırız.

Erişiciler (iterator), algoritmalarla toplulukları birbirlerinden soyutlarlar. karıştır, baş tarafı ve sonu belirleyen iki erişici alacak şekilde tasarlarsak, topluluğun kendi içindeki belirli bir aralığı bile karıştırabiliriz:

// Hepsini değil, ortasını karıştır
karıştır(dizi.begin() + 3, dizi.end() - 5);

// Aynı algoritma liste için de çalışır
karıştır(liste.begin() + 3, liste.end() - 5);

(Aslında liste için perde arkasında daha hızlı başka algoritma kullanılıyor da olabilir ama kullanıcı kodu açısından aynı şekilde yazılır.)

Erişicilerin yararı o...

Aralıklar (range) yalnızca 0..10 gibi sayı aralıkları değil, bir topluluğun belirli bir eleman aralığı anlamına geliyor.

Aralıklar, aslında perde arkasından o iki erişinin bir araya gelmesinden başka bir şey değildir. Aralık kullanan karıştır işlevi şöyle yazılabilir:

karıştır(istediğim_dizi_aralığı);
karıştır(istediğim_liste_aralığı);

İki erişici bir araya gelince, artık algoritmalardan aralıklar döndürülebiliyor. (İşlevlerin tek dönüş değeri olabildiği için iki erişici döndüremezler.) Böylece algoritmalar lego parçaları gibi birbirlerine bağlanabiliyorlar.

Temelde o... :)

Ali

--
[ Bu gönderi, http://ddili.org/forum'dan dönüştürülmüştür. ]

Başlık önemli değil.Bence böyle daha uygun olmuş.

Yazdığınız kodu hemen deneyeceğim.

Kod sonuç olarak 3500 1500 yazdı ekranda.

--
[ Bu gönderi, http://ddili.org/forum'dan dönüştürülmüştür. ]

Alıntı (canalpay):

Bu kadar kısa zamanda yazılmış olan bu kadar kısa bir yanıttan her şeyi anlamadığın için teşekkürler. ;)

Alıntı:

Toplulukların belirli bir aralığındaki elemanları ifade etmek için indeks değerleri kullanmak her veri yapısına uymaz. Örneğin bağlı listenin "yüzüncü elemanından bininci elemanına kadar" demek için erişicileri başından başlayarak o kadar kere yürütmek gerekir. Aynı şey ikili ağaç yapılarında veya başka yapılarda da vardır.

D'nin desteklediği iki adet veri yapısı var: dizi ve eşleme tablosu. Her ikisi de rahatça indekslendiği için her veri yapısında da öyle olacağını düşünüyoruz. Daha onlarca başka veri yapısı (topluluk) var ve hepsinin özellikleri farklı.
Alıntı:

Örneğin şöyle kurulmuş olabilir:

intAralığı istediğim_dizi_aralığı(dizi.begin() + 1, dizi.end() - 1);

Alıntı:

Belirli bir aralıkta bir arama yapıldığında, bulunan elemana erişici döndürülebilir. Başka algoritmalar da erişici döndürebilirler. Örneğin bir ikili ağaç yapısına eleman ekleyince yeni eklenen elemana referans olan bir erişici döndürülür, vs.

Aralık kullanan algoritmalar tek bir erişici değil, bir aralık döndürünce başka algoritmaların parametreleri olabiliyorlar:

writeln(ikiyle_çarp(çift_değerlileri_bul(benim_aralık)));

Orada çift_değerlileri_bul bir aralık döndürebiliyorsa, ikiyle_çarp'ın parametresi olarak kullanılabiliyor.

Eğer her ikisi de baş ve son erişicileri kullansaydı, ancak şöyle yazabilirdik:

BirDizi çift_değerliler = çift_değerlileri_dizi_olarak_döndür(benim_aralık);
writeln(ikiyle_çarp(çift_değerliler.begin(), çift_değerliler.end()));

Ali

--
[ Bu gönderi, http://ddili.org/forum'dan dönüştürülmüştür. ]

Alıntı (canalpay):

Erişici de aralık da dilden bağımsız bir kavram. Kütüphanelerle ilgili. C++'nın standart kütüphanesi, erişicilerin en güzel örneği olan STL'i kabul etmiştir. D'nin Phobos'u da aralıkları kabul ediyor.

Alıntı:

Erişiciler Phobos'tan yavaş yavaş azalacaktır. std.iterator modülünde STL'in eşi olacağı yazıyor ama yakında emekli olacaktır. (Öyle bir şey duymadım; aralıklara verilen öneme bakarak söylüyorum.)

Alıntı:

>     int[] dizi=[1,2,2];
>     writeln(dizi[].begin());
> ```

>

import std.stdio;
import std.iterator;

// Erişici kullanan bir algoritma
Erişici çiftOlanİlkiniBul(Erişici)(Erişici baş, Erişici son)
{
for ( ; baş != son; ++baş) {
if ((*baş % 2) == 0) {
return baş;
}
}

// Bulunamazsa, geleneksel olarak aralığın sonu döndürülür
return son;
}

void main()
{
int[] dizi=[1, 2, 2];
writeln("başı: ", dizi.begin());
writeln("sonu: ", dizi.end());

auto erişici = çiftOlanİlkiniBul(dizi.begin(), dizi.end());

if (erişici != dizi.end()) {
// bulunmuş
writeln("ilk çift olan: ", *erişici);
} else {
writeln("bulunamadı");
}
}

Ali

-- 
[ Bu gönderi, <http://ddili.org/forum>'dan dönüştürülmüştür. ]

Diziler otomatik olarak aralık olarak kullanılabildikleri için, ve std.algorithm aralıklarla çalıştığı için çok kolay:

import std.stdio;
import std.algorithm;

void main()
{
   int[] dizi=[1, 2, 2];

   auto sonuç = find!"(a % 2) == 0"(dizi);

   if (!sonuç.empty()) {
       writeln("ilk çift olan: ", sonuç.front());
       writeln("ilk bulunan eleman ve gerisi: ", sonuç);
   } else {
       writeln("bulunamadı");
   }
}

Ali

--
[ Bu gönderi, http://ddili.org/forum'dan dönüştürülmüştür. ]

std.range dışarıda kalmış. :)

find'ın karar işlevi (predicate) alanı da var:

import std.range;
import std.stdio;
import std.algorithm;

bool çift_mi(int sayı)
{
   return (sayı % 2) == 0;
}

void main()
{
   int[] dizi=[1, 2, 2];

   auto sonuç = find!çift_mi(dizi);

   if (!sonuç.empty()) {
       writeln("ilk çift olan: ", sonuç.front());
       writeln("ilk bulunan eleman ve gerisi: ", sonuç);
   } else {
       writeln("bulunamadı");
   }
}

Ali

--
[ Bu gönderi, http://ddili.org/forum'dan dönüştürülmüştür. ]

Bu arada phobos'un svn deposuna std.iterator kaldırıldı ve belgeleri derlemeden çıkarıldı. Ayrıca not olarak zaten 8 Hazirandan beri phobos'un inşasına eklenmiyordu denmiş. Ali Beyin dediği gibi oldu ve D artık daha çok aralık kullanmaya ve desteklemeye başladı ve erişicilere desteğini kesmeye başladı.

--
[ Bu gönderi, http://ddili.org/forum'dan dönüştürülmüştür. ]