Merhaba,

Bugün, daha önce söz verdiğim bir yazı dizisine başlamaya niyetlendim. Takip edeni ve beni de zorlamayacak bir hacimde (açıklamalar hariç her örnek ~10 satır) kodlar yazacağım. Bunları anlamak için derlemeniz ve/veya çalıştırmanız gerekmeyecek. Çünkü 'assert()' işlevinden ve yardımcılarından faydalanacağız:

• assert(), kısaca ve özneli bir şekilde "iddia ediyorum" anlamına gelir. Bu özel işleve verilen ilk parametre bir koşullu önerme olmak zorundadır. Eğer önermenin neticesi (dönüş değeri) 1 (true) ise bu satırda hata vermez, tersi durumunda (false) ise yazılım çalışmayı keserek hata verilen satır bildirilir
  ** is, biz eğer iki nesneyi karşılaştıracaksak bunu,
  ** typeof, nesnelerin türleri karşılaştıracaksak her ikisini de kullanırız...

Ayrıca ilerleyen satır ve örneklerde şunları da kullabiliriz:

** length, dizi (array) ve veya dizginin (string) uzunluğunu verir
** sizeof, türün bellekte kaç byte yer kapladığını verir
** stringof, türün kod içindeki ismini verir
** typeid, türün kayıtlı ismini verir

'- DEVAMI GELECEK -'

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

Alıntı:

> void main() {
> //  alias, var olan bir nesneye takma isim verir:
>     alias string dizgi;/* çok özel bir türdür ve içeriği,
>                         * immutable(char)[] dizisidir...
>                         */
> //  assert, "iddia ediyorum" anlamına gelir; örneğin:
>     int i = 1;
>     assert( i == 1 );  /* eğer i değişkeni 1'e eşitse
>                         * yazılım o satırda hata vermez...
>                         */
>     assert( is(string == immutable(char)[]) );
>
> //  D, %100 UTF'i destekler, her şey* Türkçe yazılabilir:
>     dizgi birİleti = "Merhaba Dünya";
>     assert( is(typeof(birİleti) == string) );
>
> //  Eğer aşağıdaki önermeyi == şeklinde olsaydı hata verirdi!
>     assert( birİleti.length != 13 );
>
>     /* Çünkü D, UTF desteği nedeniyle ü harfini birden fazla**
>      * karakter ile ifade eder, şu örnek de sayıldığı gibidir:
>      */
>     char[7] selamVer = [ 'M', 'e', 'r', 'h', 'a', 'b', 'a' ];
>     i = selamVer.length;
>
>     assert(i == 7);
> }
> ```

> (*) Kayıtlı sözcükler (registered keywords) hariç Türkçe yazmakta sıkıntı yoktur...
> (**) Gelenksel ASCII, 0-127 arasında tanımlanmış karakterlerden oluşur. UTF bu karakter tablosuna uyumludur ve dışında kalanları daha büyük sayı değerleri veya birden fazla karakter karşılıkları ile ifade eder.
>

Ayrıca bakınız;
* <http://ddili.org/ders/d/assert.html>
* <http://ddili.org/ders/d/alias.html>
* <http://ddili.org/ders/d/dizgiler.html>
* <http://ddili.org/ders/d/auto.html>

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

Dizgi gösterimi bizi yanıltıyor ama typeid() aslında TypeInfo diye bir tür döndürür:

http://dlang.org/phobos/object.html#TypeInfo

struct Yapı
{
   int i;
   double d;
}

void main()
{
   TypeInfo türBilgisi = typeid(Yapı);

   // Öylesine bir örnek:
   assert(türBilgisi.tsize() == Yapı.sizeof);
}

"ü harfini iki ASCII karakter ile ifade eder" tam doğru değil çünkü D'deki char türünün artık ASCII ile hiç ilgisi yok. Evet, 128'den küçük olan değerler bilerek birbirlerine denk yapılmışlardır ama char'ın UTF-8 kod birimi olduğunu söylemek daha doğru. Hatta, tam doğru konuşmak gerekirse, ü'yü oluşturan kod birimlerinin ikisi de ASCII olamaz çünkü ikisinin değeri de 127'den büyük: 195 ve 188.

Ali

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

Alıntı:

>     char[] harfler = [ 'M', 'e', 'r', 'h', 'a', 'b', 'a' ];
>
> void main() {
> //  foreach, D'de üç parametre alabilir:
>     foreach(i, harf; harfler)
>     {
>         // i == 0, 1, 2, 3, 4, 5, 6
>         assert(harfler[i] == harf);
>     }
>
> //  İlk parametre olan i, index'i verir:
>     foreach_reverse(i, harf; harfler)
>     {
>         // i == 6, 5, 4, 3, 2, 1, 0
>         assert(harfler[i] == harf);
>     }
>
> //  O halde harfler.length'e benzer bir sayım yapabiliriz...
>     int xSay = 1;
>     foreach_reverse(i, harf; harfler)
>     {
>         if(i) xSay++;
>     }
>     assert(xSay == 7);
> }
> ```

> Aslında dizilerdeki length özelliği, tıpkı işaretçi (pointer) gibi son elemanın kaç birim ileride olduğunu bize bildirir. Yani her erişim sağlandığında yukarıdaki son örnek gibi bir sayım işlemi gerçekleştirilmez.
>

Ayrıca bakınız;
* <http://ddili.org/ders/d/diziler.html>
* <http://ddili.org/ders/d/foreach_dongusu.html>

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

Salih ne iyi etmişsin.
Böyle örnekleri bol bol sunmakta yarar görüyorum.
Tebrik ederim, takipçinim.
Kolaylıklar,

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

Alıntı:

>     int[] rakamlar = [ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 ];
>
> void main() {
> //  Dilimler bir D olanağıdır ve aşağıda iki dilim vardır:
>     int[] rakam0_4 = rakamlar[0..$/2]; // 0, 1, 2, 3, 4
>     int[] rakam5_9 = rakamlar[$/2..$]; // 5, 6, 7, 8, 9
>
> //  Dilimler arasında aynı sonucu veren çıkarma yapılırken...
>     foreach(i, rakam; rakam5_9)
>     {
>         assert(rakam - rakam0_4[i] == 5); // 5 - 0 = 5 ...
>     }
>
> //  İlk dilimin gösterdiği elemanlar ters sıralanır:
>     rakam0_4.reverse;
>
> //  Dilimler arasında aynı sonucu veren toplama yapılırken...
>     foreach_reverse(i, rakam; rakam5_9)
>     {
>         assert(rakam + rakam0_4[i] == 9); // 5 + 4 = 9 ...
>     }
>
> //  Reverse, rakamlar dizisinin sadece yarısını etkilemiş*:
>     assert(rakamlar[0] == 4);
>     assert(rakamlar[5] == 5);
> }
> ```

> (*) Her ne kadar dilimler, sağdan tıpkı bir dinamik dizi gibi tanımlansa da; aslında onlar, iki işaretçi içeren özel türlerdir. Örnekte görüldüğü gibi köşeli parantez içinde sağdan yazılan ifadeler ($, length demektir), bize dizinin hangi aralığını (iki noktasını) dilimleyeceğini gösterir. Göstermekle kalmaz, dilime yapılan işlemler doğrudan diziyi etkiler...
>

Ayrıca bakınız;
* <http://ddili.org/ders/d/diziler.html>
* <http://ddili.org/ders/d/dilimler.html>

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

Alıntı:

>     int[] rakamlar = [ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 ];
>
> void main() {
> //  Aşağıdaki, 10 elemanlı dizinin bir eksiğinde dilimdir:
>     int[] dilim = rakamlar[0..$-1];
>     assert (dilim.length == 9);
>
> //  İlk gösterdiği eleman sıfırdır:
>     assert (dilim[0] == 0);
>
> //  Dizinin ilk gösterdiği eleman dilim yoluyla değişirse...
>     dilim[0] = 9;
>
> //  Aynı anda dizide de değişecektir çünkü paylaşımdadır:
>     assert (rakamlar[0] == 9);
>
> //  Dilimin sonuna bir eleman daha eklediğimizde...
>     dilim ~= 0;
>
> //  Dilim ile dizinin boyutu eşit oldu ama !!!
>     assert(dilim.length == rakamlar.length);
>
> //  Dilim artık bir dizidir, çünkü paylaşım bozulmuştur:
>     alias dilim bozulmuşDilim;
>     assert(bozulmuşDilim[9] != rakamlar[9]); // 9 != 0
> }
> ```

>

Paylaşımın bozulma örneğidir ve devam edecektir...

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

Alıntı (Salih Dinçer):

> > //  Dilim artık bir dizidir, çünkü paylaşım bozulmuştur:
> > ```

> >
>

"Dilim artık dizidir" yanıltıcı olabilir.

'dilim ~= 0' yapıldığında 'dilim'in sonuna yeni bir eleman ekleniyor ama orada o elemanın güvenle ekleneceği yer yok (çünkü orada 'rakamlar' diliminin bir elemanı var.).

O zaman *D çalışma ortamı* (D runtime) 'dilim'in elemanlarını önce yeni bir diziye kopyalar ve dilim'in artık onu göstermesini sağlar. Sonra 'dilim ~= 0' işlemi uygulanırken yeni elemana yer vardır.

Bu konuyla ilgili yazı da şu:

 <http://ddili.org/makale/d_dilimleri.html>

İngilizce aslının bir kopyası da şuradaymış:

 <http://dlang.org/d-array-article.html>

Ali

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