Alıntı (Salih Dinçer):

C++'ta da C ile aynı.

Alıntı:

Bu kuralların hepsinin güzel açıklamaları ve tutarlı nedenleri var ama ben artık hiç hatırlamıyorum.

Alıntı:

C++'ta da var: vector her eleman için tek bit kullanır. Yer kazancı sağlar ama gariptir de: Aynı baytı paylaşan elemanların adresleri teker teker ya alınamaz ya da aynı olmak zorundadır. Herhalde Array!bool'da da öyledir. (?) Gerçekten ihtiyaç duyduğumda bakarım. :p

Ali

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

Bir şey sorabilir miyim şimdi bu mono-D windows da kullanılacağı zaman .net framework e eklenecek mi derleyici olarak yani d.net i windows da derleme imkanı olacak mı ?

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

Alıntı:

Yanlış anlamışsınız. Monodevelop için sadece D için uygun yama. Yani adam D-ide geliştiriyordu windows için. Andrei filan dediki şu cross platform olsa ne güzel olurdu değil mi? Adamda gsoc projesi için bunu yaptı. (.Net sadece windows için)Sadece ide yani. Derleme ya da .net ile alakası yok. Yani aslında adı monodevelop-D olmalıymış. Şuan 3 derleyici filan var. Dmd, gdc ve ldc ile sdc'yi toplayıncada bir eder. Oldu 3 :-)

Alıntı:

Böyle bir şey olsa büyük ihtimalle mono ile olmaz .net framework ile olur. Sadece windows için çalışır ve linux olmazsa anlamıda kalmaz olayın. Millet windowstan soğumaya başladı. Şuan valve resti çekti. linux'a geçmeyi kafasına koydu bile. Linux iyi olanaklar sağladığı için ve orjinal oyun almayı sevdikleri için bu olay çok uzun sürmez diye tahmin ediyorum.

Net olursa çok iyi ancak asıl olay D'nin derlenebilir ve hızlı olması. Yani c++ gibi olması ve C# gibi olanakları olması. .Net'e taşındığında bunun önemi kalmaz ki?

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

Bilemiyorum d.net diye codeplex.com da bir proje belirtilmiş ancak şuanda geliştirilmiyor tahminim sadece bir fikir

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

#include <stdio.h>

int main()
{
   int dizimiz [4][5] = { {0, 1, 2, 3, 4},
                          {5, 6, 7, 8, 9},
                          {0, 1, 2, 3, 4},
                          {5, 6, 7, 8, 9} };

   int (* dizi) [5] = dizimiz;

   int satir, sutun;
   for (satir = 0; satir < 4; ++satir) {
       for (sutun = 0; sutun < 5; ++sutun) {
           printf("%d", * (* (dizi + satir) + sutun));
       }
       printf("\n");
   }
}

Peki benek sayısı artmaya başlayınca da mı ayırarak kullanalım. Örneğin

   int ( * dizi) [5] = dizimiz;

ya da

           printf("%d", * ( * (dizi + satir) + sutun));

bu şekilde. Dikkat ederseniz burada boşlukları bir arttırdım. Sonra (* dizi) ile [5], dizimizdeki [4] ve [5] gibi bitişik mi olsun.

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

Alıntı (erdem):

> #include <stdio.h>
>
> int main()
> {
>     int dizimiz [4][5] = { {0, 1, 2, 3, 4},
>                            {5, 6, 7, 8, 9},
>                            {0, 1, 2, 3, 4},
>                            {5, 6, 7, 8, 9} };
>
>     int (* dizi) [5] = dizimiz;
>
>     int satir, sutun;
>     for (satir = 0; satir < 4; ++satir) {
>         for (sutun = 0; sutun < 5; ++sutun) {
>             printf("%d", * (* (dizi + satir) + sutun));
>         }
>         printf("\n");
>     }
> }
> ```

>
> Peki benek sayısı artmaya başlayınca da mı ayırarak kullanalım. Örneğin
>

int ( * dizi) [5] = dizimiz;

>             printf("%d", * ( * (dizi + satir) + sutun));
> ```

> bu şekilde. Dikkat ederseniz burada boşlukları bir arttırdım. Sonra (* dizi) ile [5], dizimizdeki [4] ve [5] gibi bitişik mi olsun.
>

Ne yapmak istediğini anlamak için kodu, şu şekilde D'ye çevirdim:

void main() {
int[][] dizimiz = [ [0, 1, 2, 3, 4],
[5, 6, 7, 8, 9],
[0, 1, 2, 3, 4],
[5, 6, 7, 8, 9] ];

int[]*[] dizi = [ &dizimiz[0],
&dizimiz[1],
&dizimiz[2],
&dizimiz[3] ];

for(int satir = 0; satir < 4; ++satir) {
for(int sutun = 0; sutun < 5; ++sutun) {
printf("%d", *(dizi[satir].ptr + sutun));
}
printf("\n");
}
}

Elbette bunu dilimlerle de yapabilirdik ama madem işaretçi aritmetiği yapacağız öyleyse başka şey karıştırmamalıydık...:)

Verilerinin tanımlandığı ve döngünün kurulduğu üst bölümü yok farz edip asıl satıra odaklanırsak birebir D karşılığı şu olsa gerek:

Alıntı:
>

        printf("%d", *(dizi[satir].ptr + sutun));

Elbette dizi[satir] şeklinde kullanmış olmam da bir fark ama burada .ptr sayesinde bir yıldızdan kurtulmuş olmamız önemli bir fark. Peki aritmetik yapmayıp biraz cimnastik yaparsak başka farklı ne yapabiliriz? Önce .ptr'yi kaldıralım:

Alıntı:

>             printf("%d", (*dizi[satir])[sutun]);
> ```


Şimdi de yıldızı kaldırıp .ptr'yi koyalım:

Alıntı:
>

        printf("%d", dizi[satir].ptr[sutun]);

Hoş değil mi...:)

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

Alıntı (erdem):

Bence parantez olmasın çünkü o kafa karıştırıyor. Şöyle bana daha güzel görünüyor:

   int* dizi[4]; // veya int *dizi[4]; ve hatta int * dizi[4];

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

Çok ilginç sonuçlar elde ettim!

Erdem, aslında diziyi temsil eden bir işaretçi tanımlamak istemiş ki o yüzden boyutunu 4 değil 5 yapmış! Ben ise her satırı işaret eden 4 işaretçi tanımlamıştım. Bu durumda D'de şöyle yapmalıydık:

int * dizi = dizimiz[3].ptr;

Peki neden 3?

Cevabı çok ilginç, biraz da D'deki bellek yerleşimi ve işaretçi aritmetiği ile ilgili. Eğer yukarıdaki gibi dizinin son satırını işaret ederseniz döngü içinde odaklandığımız satırın şu şekilde olması gerekiyor:

printf("%d, ", *( dizi + sutun + satir * 8 ) );

Çünkü veriler belleğe ters işleniyor. Sanırım Ali hocam, D.ershane'deki bir dersde, D'de değişkenlerin aşağıdan yukarıya doğru tanımlandığını o yüzden main() dışındaki işlevlerin herhangi bir yerde (yani C'deki gibi değil!) olabileceğini yazmıştı. İşte bu yüzden yukarıdaki satırın çıktısı ne yazık (belki de bir gün işimize de yarar?) ki ters olmakta:
Alıntı:

Not: 2. satırı "1, 3, 5, 7, 9," ile değiştirmiştim...

Peki, şimdi işaret eden değişkenimiz (dizi), dizimiz'in başını (dizimiz[0].ptr) gösterirse n'olur? İşte o zaman işler karışıyor ve çıkarma işlemi yapmamız gerekiyor. Çıktının istediğimiz şekilde düz olması için satır şu:

printf("%d, ", *( dizi + sutun - satir * 8 ) );

Şimdi soruyorum...

Peki neden 8?

Tamam, bu bir bayt'ın içerdiği 8 bit demek olabilir. Belki derleyicinin 32 bit olmasından da kaynaklanabilir. Ama dikkat 32 bit'de size_t.sizeof = 4'dür. Bu 2x demek ama hala 8'in nereden geldiğini anlamış değilim...:)

Alıntı (acehreli):

>     :    :    :
>     int (*dizi)[5] = dizimiz;
>     :    :    :
> ```

>
Hocam, neden parantez kullanıyorsunuz?

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

Hmm anladım, peki o satırın eşdeğeri şu olabilir mi? Çünkü aynı sonucu veriyor...
Alıntı ("C KODU"):

> int * dizi[4];
>
>       dizi[0] = dizimiz[0];
>       dizi[1] = dizimiz[1];
>       dizi[2] = dizimiz[2];
>       dizi[3] = dizimiz[3];
> ```

>

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

Aslında buradaki çift benekli göstergelerin dizilerle nasıl kullanılacağını daha önce Ali bey Yahoo Cdili grubunda anlatmıştı. Ben de ordan öğrendim.

http://tech.groups.yahoo.com/group/cdili/message/1647

Hatta "Aslında insan bunun nedenini tam anlamadan da hayatını sürdürebilir" yazmış :)

Alıntı (Salih Dinçer):

Parantez kullanmazsak int göstergelerden oluşan bir dizi olmuş oluyor.

   int * dizi[8];  // 8 tane int göstergesinden oluşan bir dizi
   int (*dizi)[8]; // 8 tane tamsayıdan oluşan bir dizi için gösterge

Bu konuda Ali bey de zaten açıklama yazmış. Ama linux altında 'cdecl' aracını da kullanabilirsin.

Alıntı:

Bunu yapabilmemizin nedeni 'sayilar[2]' aslında '*(sayilar + 2)' demek.

#include <stdio.h>

int main()
{
   int sayilar[5] = {10, 20, 30, 40, 50};
   int * ptr;
   ptr = sayilar;

   printf("%d", sayilar[2]);
   printf("%d", ptr[2]); // göstergeyi dizi gibi kullanıyorum

   printf("%d", *(sayilar + 2));
   printf("%d", *(ptr + 2)); // sayilar[2] demekle aynı şey
}

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