C'deki en yaygın adlandırma kuralları nelerdir?

C'de yaygın olarak kullanılan adlandırma kuralları nelerdir? En az iki tane olduğunu biliyorum:

1. Küçük harfli_fonksiyonlu GNU / linux / K&R
2. ? isim? UpperCaseFoo işlevleriyle

Sadece burada C'den bahsediyorum. Projelerimizin çoğu, C kullandığımız küçük gömülü sistemlerdir.

İşte bir sonraki projem için kullanmayı planladığım proje:

C Adlandırma Sözleşmesi

Struct              TitleCase
Struct Members      lower_case or lowerCase

Enum                ETitleCase
Enum Members        ALL_CAPS or lowerCase

Public functions    pfx_TitleCase (pfx = two or three letter module prefix)
Private functions   TitleCase
Trivial variables   i,x,n,f etc...
Local variables     lower_case or lowerCase
Global variables    g_lowerCase or g_lower_case (searchable by g_ prefix)

Buradaki en önemli şey tutarlılıktır. Bununla birlikte, aşağıdaki gibi özetlenebilecek GTK + kodlama kuralını takip ediyorum:

1. Tüm makrolar ve sabitler büyük harf: MAX_BUFFER_SIZE, TRACKING_ID_PREFIX.
2. Camelcase'de Struct isimleri ve typedef'ler: GtkWidget, TrackingOrder.
3. Yapılar üzerinde çalışan fonksiyonlar: klasik C stili: gtk_widget_show(), tracking_order_process().
4. İşaretçiler: burada fantezi bir şey yok: GtkWidget *foo, TrackingOrder *bar.
5. Global değişkenler: sadece global değişkenler kullanmayın. Onlar kötüler.
6. Orada olan, ancak doğrudan çağrılmaması gereken veya belirsiz kullanımları olan işlevler veya her neyse: Başlangıçta bir veya daha fazla alt çizgi: _refrobnicate_data_tables(), _destroy_cache().

"Struct işaretçileri", onları kapsayacak şekilde bir adlandırma kuralına ihtiyaç duyan varlıklar değildir. Onlar sadece struct WhatEver *. Zeki ve "bariz" bir typedef ile ilgili bir işaretçi olduğu gerçeğini SAKLAMAYIN. Hiçbir amaca hizmet etmez, artık yazmak içindir ve bildirim ile erişim arasındaki dengeyi bozar.

Öncelikle C'nin genel / özel / sanal işlevleri yoktur. Bu C ++ 'dır ve farklı kuralları vardır. C'de tipik olarak şunlara sahip olursunuz:

• ALL_CAPS içindeki sabitler
• Yapılarda veya işlev adlarında sözcükleri sınırlandırmak için alt çizgiler, C'de neredeyse hiç deve durumu görmezsiniz;
• yapılar, typedef'ler, sendikalar, üyeler (sendika ve yapıların) ve enum değerleri genellikle C ++ / Java / C # / etc ilk harfi büyük harf yapma kuralından ziyade küçük harflidir (benim deneyimlerime göre), ancak sanırım bu mümkün C de.

C ++ daha karmaşıktır. Burada gerçek bir karışım gördüm. Sınıf adları veya küçük harf + alt çizgi için deve durumu (deve durumu benim deneyimime göre daha yaygındır). Yapılar nadiren kullanılır (ve genellikle bir kitaplık gerektirdiği için, aksi takdirde sınıfları kullanırsınız).

Biliyor musun, basit ama açık tutmayı seviyorum ... İşte burada kullandığım şey, C:

• Önemsiz Değişkenler : i,n,cvb ... (Yalnızca bir harf. Bir harf net değilse, Yerel Değişken yapın)
• Yerel Değişkenler :lowerCamelCase
• Global Değişkenler :g_lowerCamelCase
• Sabit Değişkenler :ALL_CAPS
• İşaretçi Değişkenleri : p_öneke bir ekleyin . Global değişkenler için gp_var, yerel değişkenler p_variçin, sabit değişkenler için olacaktır p_VAR. Uzak işaretçiler kullanılıyorsa, fp_yerine bir kullanın p_.
• Yapılar : ModuleCamelCase(Modül = tam modül adı veya 2-3 harfli bir kısaltma, ancak yine de CamelCase.)
• Struct Üye Değişkenleri :lowerCamelCase
• Numaralandırmalar :ModuleCamelCase
• Enum Değerleri :ALL_CAPS
• Genel İşlevler :ModuleCamelCase
• Özel İşlevler :CamelCase
• Makrolar :CamelCase

Yapılarımı yazdım, ancak hem etiket hem de typedef için aynı adı kullanıyorum. Etiketin yaygın olarak kullanılması amaçlanmamıştır. Bunun yerine typedef'i kullanmak tercih edilir. Ayrıca typedef'i kapsülleme için genel modül başlığında bildiririm ve böylece typedef'd adını tanımda kullanabilirim.

Tam struct Örnek :

typdef struct TheName TheName;
struct TheName{
    int var;
    TheName *p_link;
};

C #, java, C, C ++ ve aynı zamanda C hedefinde kodlama yaparak , hayatımı kolaylaştırmak için çok basit ve net bir adlandırma kuralı uyguladım.

Her şeyden önce, modern IDE'lerin (eclipse, Xcode ... gibi) gücüne dayanıyor, fareyle veya ctrl tıklama ile hızlı bilgi alma imkanı ... Bunu kabul ederek, herhangi bir önek, sonek kullanımını bastırdım. ve sadece IDE tarafından verilen diğer işaretler.

Ardından, kongre:

• Her isim, sahip olduklarınızı açıklayan okunabilir bir cümle OLMALIDIR. "Bu benim sözleşmem" gibi.
• Ardından, bir cümle içinden bir kongre çıkarmanın 4 yöntemi:
  1. Makrolar için THIS_IS_MY_CONVENTION , enum üyeleri
  2. ThisIsMyConvention dosya adı, nesne adı (sınıf, yapı, enum, birlik ...), fonksiyon adı, yöntem adı, typedef için
  3. this_is_my_convention global ve yerel değişkenler,
     parametreler, yapı ve birleşim öğeleri
  4. thisismyconvention [isteğe bağlı] çok yerel ve geçici değişkenler (for () döngü dizini gibi)

Ve bu kadar.

O verir

class MyClass {
    enum TheEnumeration {
        FIRST_ELEMENT,
        SECOND_ELEMENT,
    }

    int class_variable;

    int MyMethod(int first_param, int second_parameter) {
        int local_variable;
        TheEnumeration local_enum;
        for(int myindex=0, myindex<class_variable, myindex++) {
             localEnum = FIRST_ELEMENT;
        }
    }
}

Deve durumu ile alt çizgi ayrımını karıştırmamanızı tavsiye ederim (yapı üyeleri için önerdiğiniz gibi). Bu kafa karıştırıyor. Düşünürsünüz, hey var, get_lengthyani muhtemelen yapmalıyım make_subsetve sonra bunun aslında olduğunu anlarsınız makeSubset. En az şaşkınlık ilkesini kullanın ve tutarlı olun.

Yapı, typedef ve enums gibi isimleri yazmak için CamelCase'i yararlı buluyorum. Yine de hepsi bu kadar. Geri kalan her şey için (fonksiyon isimleri, struct üye isimleri vb.) Altçizgi_separation kullanıyorum.

İşte faydalı bulduğum (görünüşe göre) nadir bir tanesi: CamelCase'deki modül adı, ardından bir alt çizgi, ardından CamelCase'de işlev veya dosya kapsamı adı. Yani mesela:

Bluetooth_Init()
CommsHub_Update()
Serial_TxBuffer[]

Bir şey kafam karıştı: Yeni bir proje için yeni bir adlandırma kuralı oluşturmayı planlıyorsunuz. Genelde şirket veya ekip çapında bir adlandırma kuralınız olmalıdır. Halihazırda herhangi bir adlandırma kuralı biçimine sahip projeleriniz varsa, yeni bir proje için kuralı değiştirmemelisiniz. Yukarıdaki sözleşme sadece mevcut uygulamalarınızın kodlanması ise, o zaman altındasınız. Mevcut fiili standartlardan ne kadar farklı olursa, yeni standartta fikir paylaşımı kazanmak o kadar zor olacaktır.

Ekleyeceğim tek öneri, uint32_t ve size_t tarzındaki türlerin sonunda _t'yi beğenmiş olmamdır. Bazıları "tersine" Macarca olduğundan şikayetçi olsa da, bu benim için çok C-ish.

Ayrıca düşünmesi gereken kelimelerin sırayla yapmak için oto ismi tamamlamayı kolaylaştırır.

İyi bir uygulama: kitaplık adı + modül adı + işlem + konu

Bir bölüm ilgili değilse, atlayın, ancak en azından bir modül adı ve her zaman bir eylem sunulmalıdır.

Örnekler:

• İşlev adı: os_task_set_prio, list_get_size,avg_get
• tanımlayın (burada genellikle eylem bölümü yoktur ):OS_TASK_PRIO_MAX

Çok sayıda olabilir, özellikle IDE'ler bazı eğilimleri belirler ve C ++ kuralları da zorlayıcıdır. C için yaygın olarak:

• UNDERSCORED_UPPER_CASE (makro tanımları, sabitler, sıralama üyeleri)
• undercored_lower_case (değişkenler, işlevler)
• CamelCase (özel türler: yapılar, numaralandırmalar, birlikler)
• uncappedCamelCase (oppa Java stili)
• UnderScored_CamelCase (değişkenler, ad alanı türlerinin altındaki işlevler)

Küreseller için Macar gösterimi iyidir, ancak türler için değildir. Ve önemsiz isimler için bile lütfen en az iki karakter kullanın.

Bunların yeni başlayanlar için yardımcı olabileceğini düşünüyorum: c'deki değişkenlerin adlandırma kuralı

1. Alfabetik Karakter (az, AZ), Rakam (0-9) ve Alt Skor (_) kullanmanız gerekir. %, $, #, @ Vb. Gibi özel bir Karakter kullanımına izin verilmez. Dolayısıyla, kullanıcı_adı değişkenini kullanabilir ancak kullanıcı & adı kullanamazsınız .
2. Kelimeler arasında boşluk kullanılamaz. Dolayısıyla, kullanıcı_adı veya kullanıcı adı veya kullanıcı adını değişken olarak kullanabilirsiniz ancak kullanıcı adını kullanamazsınız .
3. Rakamla isimlendirmeye başlanamaz. Dolayısıyla, değişken olarak user1 veya user2'yi kullanabilirsiniz ancak 1user kullanamazsınız .
4. Büyük / küçük harfe duyarlı bir dildir. Büyük ve küçük harf önemlidir. Kullanıcı adı gibi bir değişken kullanıyorsanız , baba kullanımı için USERNAME veya Username kullanamazsınız.
5. Değişken bildirimi için herhangi bir anahtar sözcük (char, int, if, for, while vb) kullanamazsınız .
6. ANSI standardı, bir değişken adı için 31 karakterlik bir uzunluk tanır