Üzerinde çalıştığım kodda şu şekilde bir ifade var.

Şimdi bu kodu yazarken bu şekilde mi yazmalı

  // yöne göre paletleri çiz
   if (yon == 0 || yon == 2) {
       rectfill(screen, x - 16, y - 16, x - 11, y + 16, GRI);
       rectfill(screen, x + 11, y - 16, x + 16, y + 16, GRI);
   }

Yoksa aralardaki boşlukları birleştirerek mi yazmalı.

  // yöne göre paletleri çiz
   if (yon == 0 || yon == 2) {
       rectfill(screen, x-16, y-16, x-11, y+16, GRI);
       rectfill(screen, x+11, y-16, x+16, y+16, GRI);
   }

Aslında bir kodlama standardımız var biliyorum.

http://ddili.org/wiki/index.php?title=Kodlama_Standard%C4%B1

Ama içeriğini biraz daha genişletmek gerekecek sanırım. Ben de o kadar alışmışım ki kodlama standardına diğer türlü sanki çorba gibi kod yazıyormuşum gibi geliyor ;-)

Bir de özellikle göstergeleri kodlarken hep karıştırıyorum. Hatta bu konuda da farklı kodlama stilleri var sanırım.

Gene switch case ifadelerini de if ifadelerinde olduğu bir boşluk küme parantezi '{' şeklinde mi yazıyorduk.

   if (bir_şey) {
       şunu_yap();
       falan();
       filan()

   } else if (başka_bir_şey) {
       bunu_yap();
       su_iç_gel();

   } else {
       diğer_şeyi_yap();
       çay_demle();
   }

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

Gösterge işaretinin (Klein Star*, asterix) iki nesnenin ortasında kullanımını doğru bulmuyorum. Çünkü bu işareti biz çarpmada da kullanıyoruz ve genellikle aritmetik işlemlerde, işaretin her iki yanına da boşluk koyuyoruz. Özetle, bir yana bitişik kullanım ortada kullanıma göre daha doğru olduğunu düşünüyorum...

Bence tür tanımlarken sola bitişik kullanmak da diğerine göre daha doğru!

Sola bitişik ve sağa bitişik kullanımlarının farkını açıklayarak şöyle sınıflandırırsak bana hak vereceğinizi düşünüyorum...:)

Biliyorsunuz, bu işareti bir de işaretçinin gösterdiği adresteki değeri döndürmesi için kullanmaktayız. Genellikle de solunda bir şey olmadan veya solundaki ile ilintili olmadan sağa bitişik yazmalıyız. Çünkü o işaret her zaman sağdaki değişken ile ilgilidir.

Tür tanımlarken de sola yazmamız, yukarıdaki açıklamadan dolayı farkını göstermek için doğru görünüyor. Çünkü her tür alışık olduğumuz (char, int vb.) isimlerde de kullanılmıyor. Örneğin bir kütüphanedeki (içeriğini bilmiyoruz) tür işaretçi olarak tanımlandıysa biz bunu, kendi programımızda sola dayanık şekilde yazmalıyız. Çünkü o işaret sağdaki ile ilgili değil soldaki ile doğrudan ilgilidir. Dolayısıyla türün özelliğini bir nevi sola aktarır.

Aslında sola bitişik yazmayı tercih etmemin bir sebebi daha var, örnekleyeyim:

Alıntı:

> bool
> öyle_mi () { //... }
>
> // yazım desenine alıştığınızı var sayalım, peki işaretçiyi ne yapacağız?
>
> const char*
> hacmi (int en, int boy, int yükseklik) { //... }
> ```

>
>

Gördüğünüz gibi işlev türünü satır ile böldüğümüz durumlarda yıldızın yukarıda tür ile birlikte kalması daha yakışıklı.

Sol parantez yanındaki boşluklara gelince, ben güzel parantezlerden önce boşluk bırakırım. İşlev tanımlarken de bırakmaya gayret ediyorum ama bunları kullanırken ve for(), if(), with() gibi içişlevlerde özellikle boşluk bırakmıyorum. Tabi sağ parantezlerde de bırakmayabiliriz ama bırakınca daha güzel durduğunu düşünüyorum.

İster sol, ister sağ kullanın yeterki kusursuz kodlayın! İyi bayramlar...

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

Titizliğin için teşekkürler! :) Gerçekten çok önemli konular...

Alıntı (erdem):

>    // yöne göre paletleri çiz
>     if (yon == 0 || yon == 2) {
>         rectfill(screen, x - 16, y - 16, x - 11, y + 16, GRI);
>         rectfill(screen, x + 11, y - 16, x + 16, y + 16, GRI);
>     }
> ```


Boşluklar çok standart. Çalıştığım her projede başkaları da hep öyle yaptılar.

Alıntı:
>  Bir de özellikle göstergeleri kodlarken hep karıştırıyorum. Hatta bu konuda da farklı kodlama stilleri var sanırım.

Sanırım yıldızın değişkene yapışık olması daha standart:

int p; // yaygın olan
int p; // seyrek olan
int * p; // daha seyrek olsa da Ali'nin sevdiği

Alıntı:
> Gene switch case ifadelerini de if ifadelerinde olduğu bir boşluk küme parantezi '{' şeklinde mi yazıyorduk.

Evet. Galiba kural şöyle: anahtar sözcükten sonra gelen parantezden önce boşluk var. İşlev çağırırken boşluk yok.

Ali

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

Belki de uyumlu olsun diye hepsini sağa bitişik yazmalıyız. Çünkü aklıma, bir de eşitlik önce kullandığımız çarpma işleçi geldi. Onu da büyük çoğunlukla sağa bitişik yazıyoruz...:)

Örneğin şöyle bir işlev yazabilirdik:

void kareleri (int *a, int *b) {
   *a *= *a;
   *b *= *b;
}

Bu arada başka bir kişisel görüşümü de paylaşmak isterim. Yine, şu yukarıdaki işlevden aklıma geldi. İşaretçilerin olmadığı bir dünya düşünseydik elbette bir çok saç baş yolma hadisesi yanında, her işlev tek değer döndürebilecekti. İşte onlar sayesinde, yukarıdaki gibi bir işlevde giren tüm parametreler aynı zaman işlenip çıkmış oluyor. Çok güzel değil mi?

Buradan, D'nin in/out parametre takılarına gelirsek... Zannedersem onlar da bir tür işaretçi kullanmakta?

Sanki D'de, özellikle dilimlerde olmak üzere işaretçilerin bir ağırlığı var! Ama bize bunları hissettirmeden, bir başka tabirle yıldızları göstermeden uyguluyorlar. Belki ref takısı da bunlardan biri ve şu tartıştığımız yıldızlar yok...:)

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

Alıntı (Ali Çehreli):

> int a;
> ref int r = a; // <-- 'ref' böyle kullanılamıyor (oysa C++'ta bile & karakteri ile referans)
> int * p = &a;  // <-- Böyle yapmak gerekiyor
> ```

> Aynısı kısıtlama yapı veya sınıf üyelerinde de var: Onlar da 'ref' olamıyorlar.
>

Örnekler için teşekkürler...

İster istemez D.ershane'deki dersleri/örnekleri göz gezdirme gereği duyuyorum. Örneğin İşlevler başlığındaki, iki boyutlu diziler ve takma adları gösteren 2. örnek çok güzel. Açıklamaların gereksizliği, bir süre sonra (kod geliştikçe) anlamsızlaşması ve bunları azaltmak için işlev sayılarını arttırma gibi şeyler öğrendim. Gerçi artık tek return'lük işlevlere bile yeşil ışık yakmaya, işleri kolaylaştırdığını anlamaya başladım. Tıpkı insanı oluşturan hücreler hiyerarşisi gibi...:)

Sevgiler, saygılar...

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

Alıntı (Salih Dinçer):

Dediğim gibi, bu konuda çok tartışma vardır. Senin beğendiğin yöntem dil kurallarına uymuyor. Ben de senin gibi keşke aşağıdaki tanımda iki gösterge tanımlanmış olsa diye düşürüm ama ilki gösterge, ikincisi int'tir:

   // C kodu:
   int* p0, p1;

Bazı insanlar o yüzden yıldızın her zaman için sağda olmasını savunurlar:

   // C kodu:
   int *p0, *p1;

İşte şimdi programcının istediği gibi ikisi de gösterge.

Alıntı:

> bool
> öyle_mi () { //... }
>
> // yazım desenine alıştığınızı var sayalım, peki işaretçiyi ne yapacağız?
>
> const char*
> hacmi (int en, int boy, int yükseklik) { //... }
> ```

>
> Gördüğünüz gibi işlev türünü satır ile böldüğümüz durumlarda yıldızın yukarıda tür ile birlikte kalması daha yakışıklı.

"daha yakışıklı" diyen sen olduğun için sana daha yakışıklı geliyor. (Bunlar kişisel görüşler.) :)

Dediğini anlıyorum; evet, kimse yıldızı alt satıra düşürmüyor. Ben şunu daha yakışıklı buluyorum:

const char *
hacmi (int en, int boy, int yükseklik) { //... }

Ali

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

Alıntı (Salih Dinçer):

in değil. out perde arkasında referans kullanıyor. Referanslar perde arkasında gösterge ile gerçekleştiriliyor.

Alıntı:

Zaten öyle olmalı. Amaç referans ise "ref" demeliyiz ve bitmeli:

void kareleri (ref int a, ref int b) {
   a *= a;
   b *= b;
}

(Not: İşlevin isminin karele(), katla(), vs. gibi bir şey olması gerek. :))

Alıntı:

D'nin diğer olanakları sayesinde göstergelerle ilgilenmek zorunda kalmıyoruz. Ama her nedense D'de yerel referans yok:

   int a;
   ref int r = a;    // <-- 'ref' böyle kullanılamıyor (oysa C++'ta bile & karakteri ile referans)
   int * p = &a;     // <-- Böyle yapmak gerekiyor

Aynısı kısıtlama yapı veya sınıf üyelerinde de var: Onlar da 'ref' olamıyorlar.

Ali

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

Alıntı (Salih Dinçer):

Teşekkürler. O örnek geçende paylaştığımız resim dosyası oluşturan programa benziyor: Resim iki boyutlu diziye çizildikten sonra bir şekilde çıkışa veriliyor.

Alıntı:

Güzel fikirler. ;)

Ali

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

Alıntı (acehreli:1345396514):

>     // C kodu:
>     int* p0, p1;
> ```

>
> Bazı insanlar o yüzden yıldızın her zaman için sağda olmasını savunurlar:
>
>

// C kodu:
int *p0, *p1;

Hocam, peki C++'da nasıldır? İlginçtir D1'den beri ilk örnekteki p0 ve p1 bir işaretçidir. C'de neden böyle bir şey düşünmüşler? Ama bu örneğe bakarsak yıldızın sağa bitişik olması gerektiği çıkıyor...:)

C++ ile iligli başka bir soru da aşağıdaki D yeteneğini karşılığı mevcut olup olmadığıdır:
Alıntı (acehreli):

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

Teşekkürler hocam, bazen C++'a alışmaya çalışsam mı diyorum; iş bulabilmek için...:)

Ama Mono-D bir ümit ışığı yakıyor! Çünkü .NET FrameWork'e girdik mi hangi dilin bildiğimizin bir önemi kalmayacak...

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