Şu yapıya baktıkça epey bir yabancılık hissettim. Bu konuda aydınlatıcı küçük notlara ihtiyacım var. Rica etsem ama kimden? Kim o, evet kim o...:)

Kısaca belki iki soru: (1) işlevin çift yıldızlı parametreleri ne oluyor? (2) (void*) ile yapılan tür dönüşüm ne demek oluyor? Bir de BONUS: (3) Bu tür gösterge(işaretçi) yapılarının D'de gösterimi/karşılığı nasıl?

static Babl *
image_new (BablFormat     *format,
          BablModel      *model,
          int             components,
          BablComponent **component,
          BablSampling  **sampling,
          BablType      **type,
          char          **data,
          int            *pitch,
          int            *stride)
{
 Babl *babl;

 /* allocate all memory in one chunk */
 babl  = babl_malloc (sizeof (BablImage) +
                      sizeof (BablComponent*) * (components) +
                      sizeof (BablSampling*)  * (components) +
                      sizeof (BablType*)      * (components) +
                      sizeof (void*)          * (components) +
                      sizeof (int)            * (components) +
                      sizeof (int)            * (components));
 babl_set_destructor (babl, babl_image_destruct);
 babl->image.component = (void*)(((char *)babl)                  + sizeof (BablImage));
 babl->image.sampling  = (void*)(((char *)babl->image.component) + sizeof (BablComponent*) * (components));
 babl->image.type      = (void*)(((char *)babl->image.sampling)  + sizeof (BablSampling*)  * (components));
 babl->image.data      = (void*)(((char *)babl->image.type)      + sizeof (BablType*)      * (components));
 babl->image.pitch     = (void*)(((char *)babl->image.data)      + sizeof (void*)          * (components));
 babl->image.stride    = (void*)(((char *)babl->image.pitch)     + sizeof (int)            * (components));

 babl->class_type       = BABL_IMAGE;
 babl->instance.id      = 0;
 babl->instance.name    = "slaritbartfast";
 babl->image.format     = format;
 babl->image.model      = model;
 babl->image.components = components;

 memcpy (babl->image.component, component, components * sizeof (void *));
 memcpy (babl->image.type, type, components * sizeof (void *));
 memcpy (babl->image.data, data, components * sizeof (void *));
 memcpy (babl->image.pitch, pitch, components * sizeof (int));
 memcpy (babl->image.stride, stride, components * sizeof (int));

 return babl;
}

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

Teşekkür ederim, gayet basit ve net...:)

Şu -> işaretleri C'de bence çok gereksiz. Kimi zaman nokta da kullanıldığını görüyorum. Belki her ikisi aynı anlamda değildir ama kafa karıştırıcı işte. Ayrıca kod okumayı çok zorlaştırıyor. Gerçi benzeri olan lambda (=>) da revaçta ama onu sık kullanmıyoruz...

Alıntı (acehreli):

Ben D'de çift yıldızlı kullanmayı denediğimde başaramamıştım. Denemeyi dizide yapmıştım ama herhalde başka bir anlamı vardır diye uğraşmadım.

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

1. C'de yıldız gösterge anlamına gelir. Her türün göstergesi olabildiği için göstergelerin de göstergesi olabilir:

'
char -> tek char
char* -> char göstergesi
char** -> char göstergesi göstergesi
vs.
'

2. void*, "her türden veriyi gösterebilen gösterge" demektir. Eğer 'babl->image.component'ın türü 'void*' ise, sağdaki gösterge değerini onun türüne dönüştürürüz. (Sanırım C++'ta void* dönüşümü otomatiktir; öyle açıkça yazmaya gerek yok.)

3. Göstergeler D'de de aynı biçimde kullanılırlar. C ve C++'ta da gereksiz olan -> işleci D'de bulunmaz, onun yerine de nokta kullanılır. Örneğin, babl->image.component yerine babl.image.component.

Ali

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

Aynı C'deki gibi bir ** kullanımı:

import std.stdio;

struct S
{
   int i;

   this(int i)
   {
       this.i = i;
   }
}

void S_yap(S ** p)
{
   *p = new S(42);
}

void main()
{
   S * p;
   S_yap(&p);
   writeln(*p);
}

Ama D'de öyle bir kod göremeyiz. Bunun en az iki nedeni var:

1. ref anahtar sözcüğü ikinci yıldızı gereksizleştirir:

import std.stdio;

struct S
{
   int i;

   this(int i)
   {
       this.i = i;
   }
}

void S_yap(ref S* p)  // <-- ref var
{
   p = new S(42);    // <-- *p değil
}

void main()
{
   S * p;
   S_yap(p);
   writeln(*p);
}

2. D'nin hata atma düzeneği nedeniyle işlevlerin dönüş türlerinin hata koduna ayrılması gerekmez:

import std.stdio;

struct S
{
   int i;

   this(int i)
   {
       this.i = i;
   }
}

S* S_yap()  // <-- ürettiğini döndürüyor
{
   return new S(42);
}

void main()
{
   S * p = S_yap();
   writeln(*p);
}

Ali

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