Ali hocam aslında enum da bir tür yaratıyor gibi düşünüyorum bu durumda aşağıdaki kod;

import std.stdio;
void main() {
   enum OyunKağıdıRengi { maça, kupa, karo, sinek }
   enum ParaAtışı { yazı, tura, dik}
   for (auto renk = OyunKağıdıRengi.min; renk <= OyunKağıdıRengi.max; ++renk) {
   writefln("%s: %d", renk, renk);
   }
   ParaAtışı para;
   para=para.tura;
   foo(para);
}

void foo(ParaAtışı paranoya){
   writeln(paranoya, ++paranoya);
   return;
}

buradaki işlev "'void foo(ParaAtışı paranoya){'" ParaAtışı türünden bir parametreyi neden kabul etmiyor ?

hata mesajı;
'c@C:~/programlama$ dmd -m64 d3.d
d3.d(13): Error: undefined identifier ParaAtışı
c@C:~/programlama$ '

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

Alıntı (acehreli):

Bu satır anlamama yetti. Ama ben yine beklerdim D den bunu anlamasını.

Alıntı (acehreli):

for dan mı uzak durmak gerek foreach ten mi Ali hocam anlayamadım?

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

Ali hocam kapsamlar konusunu iyice özümsedim teşekkürler.

Başka bir konuya geçiş yaptım gibi olacak ama bir şey dikkatimi çekti! Sınıf veya işlev Global olarak tanımlandığında(main dışında) eğer yanılmıyorsam C/C++ dillerinde bir sıralama gerektiriyordu. Yani foo1() ve foo2() global alanda yazılmışsa ve foo2(), içinde foo1() çağrısı yapıyorsa, foo1() fooo2()'nin daha üstünde yazılması gerekiyordu. Ama yanılmıyorsam D dilinde Global alanda böyle bir ayırım yok!! bu doğrumudur Ali hocam ?

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

main'in içinde tanımlanan isim dışarıdan görülemez. Bütün isimler kapsamlarla ilgilidir.

Uzaktan ilgili olarak, enum'ın değerlerini std.traits.EnumMembers'la da görebilirsin:

import std.traits;

void main() {
 enum OyunKağıdıRengi { maça, kupa, karo, sinek }
 foreach (renk; EnumMembers!OyunKağıdıRengi) {
   // ...
 }
}

Bunun nedeni, aşağıdaki programda görülüyor:

import std.stdio;

enum ÖzelDeğerler {
 sıfır = 0,
 yedi = 7,
}

void main() {
 for (auto değer = ÖzelDeğerler.min; değer <= ÖzelDeğerler.max; ++değer) {
   writeln(değer);
 }
}

Çıktı, ++ işleci kullanıldığında saçma:
'
sıfır
cast(ÖzelDeğerler)1
cast(ÖzelDeğerler)2
cast(ÖzelDeğerler)3
cast(ÖzelDeğerler)4
cast(ÖzelDeğerler)5
cast(ÖzelDeğerler)6
yedi
'
Daha uzaktan ilgili olarak, D'nin aralıkları (range) ve foreach döngüsü, for döngüsüne hemen hemen hiç gerek bırakmıyor. Olabildiğince uzak durmak gerek. :)

Ali

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

Alıntı (cos00kun):

İsimlerin kapsamların dışından erişilememeleri modern programlama dillerinin çok önemli bir özelliğidir. Öyle olmasaydı hiçbir ismi tekrar kullanamazdık:

void foo() {
 int i = 42;
}

void bar() {
 double i = 1.5;  // HATA: "i daha önce int olarak tanımlanmıştı" (saçma :) )
}

Birbirelerine karışmasınlar diye her ismi uzun seçmek zorunda kalırdık:

void foo() {
 int benim_programım_falanca_modül_foo_işlevi_i = 42;
}

İsim gizleme çok yararlı bir olanaktır.

Alıntı:

Modern programcılık açıkça yazılan döngülerden olabildiğince uzak durmayı önerir. Aşağıdaki sıralamaya uygun olarak kullanmak gerek:

• Öncelikle aralıklar
• Sonra foreach
• Sonra for
• (Şaka olarak) Etiket ve döngü (dediğim gibi, şaka :) )

import std.stdio;

auto çift_mi(int i) {
 return (i % 2) == 0;
}

auto karesi(int i) {
 return i * i;
}

// Çift sayı olanların karelerini döndürür
auto çiftlerinKareleri_aralık_algoritması(A)(A aralık) {
 import std.algorithm;

 return aralık.filter!çift_mi.map!karesi;
}

// Çift sayı olanların karelerini döndürür
auto çiftlerinKareleri_foreach(const(int[]) dizi) {
 int[] sonuç;

 foreach (eleman; dizi) {
   if (çift_mi(eleman)) {
     sonuç ~= karesi(eleman);
   }
 }

 return sonuç;
}

// Çift sayı olanların karelerini döndürür
auto çiftlerinKareleri_for(const(int[]) dizi) {
 int[] sonuç;

 for (auto i = 0; i < dizi.length; ++i) {
   if (çift_mi(dizi[i])) {
     sonuç ~= karesi(dizi[i]);
   }
 }

 return sonuç;
}

// Çift sayı olanların karelerini döndürür
auto çiftlerinKareleri_goto(const(int[]) dizi) {
 int[] sonuç;
 auto i = 0;

döngüBaşı:
 if (i == dizi.length) {
   return sonuç;
 }

 if (çift_mi(dizi[i])) {
   sonuç ~= karesi(dizi[i]);
 }
 ++i;
 goto döngüBaşı;
}

void main() {
 const dizi = [ 1, 2, 3, 4, 5, 6 ];
 writeln(çiftlerinKareleri_aralık_algoritması(dizi));
 writeln(çiftlerinKareleri_foreach(dizi));
 writeln(çiftlerinKareleri_for(dizi));
 writeln(çiftlerinKareleri_goto(dizi));
}

Bir kere alışınca, aralık kullanan algoritma diğerlerinden daha kısa, hata yapma şansı daha az, ve ne iş yapıldığı açıkça görülüyor. (Biraz alışmak ve İngilizce gerekebilir: filter, "süz" demek; "map", "verilen değere karşılık şunu üret" demek, vs.) Diğerleri hataya açık: Örneğin, o kodları yazarken karesi() işlevini çağırmayı unuttum, for döngüsünde i'yi yanlış olarak dizi.length ile ilkledim, goto'da ++i'yi fazla önceki bir noktaya yerleştirdim. (Yalan değil: Bu hataları onları yaptım ama neyse ki daha yazarken farkettim.)

Ali

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

Doğru. Bu da çok yararlı bir olanak. Bunun sayesinde kodu oradan oraya taşımak veya bildirimle tanımı ayrı yerde yapmak zorunda kalmıyoruz.

Ali

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