Adlandırma kuralı - C ++ ve C # değişkenlerinde alt çizgi

_varSınıf alanında değişken adı görmek yaygındır . Alt çizgi ne anlama geliyor? Tüm bu özel adlandırma kurallarına referans var mı?

Alt çizgi basitçe bir kongre; başka bir şey değil. Bu nedenle, kullanımı her insan için her zaman biraz farklıdır. Söz konusu iki dil için bunları şu şekilde anlıyorum:

C ++ 'da, alt çizgi genellikle özel üye değişkenini belirtir.

C #, genellikle sadece bir ortak özellik için temel özel değişken değişken tanımlarken kullanılan görüyorum. Diğer özel üye değişkenlerin alt çizgisi yoktur. Bu kullanım, otomatik özelliklerin ortaya çıkmasıyla büyük ölçüde yol kenarına gitti.

Önce:

private string _name;
public string Name
{
    get { return this._name; }
    set { this._name = value; }
}

Sonra:

public string Name { get; set; }

C ++ 'da herhangi bir değişken adından veya parametre adından önce UNDERSCORES kullanmamanız en iyi uygulamadır

Alt çizgi veya çift alt çizgi ile başlayan isimler C ++ uygulayıcıları için REZERVE EDİLİR. Alt çizgi içeren isimler kütüphanenin çalışması için ayrılmıştır.

C ++ Kodlama Standardında bir okumanız varsa, ilk sayfada şunu söylediğini göreceksiniz:

"Adlandırmayı abartmayın, ancak tutarlı bir adlandırma kuralı kullanın: Yalnızca iki zorunlu dosya vardır: a)" altını çizen adlar ", alt çizgi ile başlayan veya çift alt çizgi içeren adlar kullanmayın;" (p2, C ++ Kodlama Standartları, Herb Sutter ve Andrei Alexandrescu)

Daha spesifik olarak, ISO çalışma taslağı gerçek kuralları belirtir:

Ayrıca, bazı tanımlayıcılar C ++ uygulamaları tarafından kullanılmak üzere ayrılmıştır ve başka şekilde kullanılmamalıdır; teşhis gerekli değildir. (a) Bir çift alt çizgi __ içeren veya bir alt çizgi ve ardından bir büyük harf ile başlayan her tanımlayıcı, herhangi bir kullanım için uygulamaya ayrılmıştır. (b) Alt çizgiyle başlayan her tanımlayıcı, genel ad alanında ad olarak kullanılmak üzere uygulamaya ayrılmıştır.

Yukarıdaki sınırlamalardan birine yanlışlıkla dolaşmanız durumunda alt çizgi ile bir sembol başlatmaktan kaçınmak en iyi uygulamadır.

Bir yazılım geliştirirken bu tür alt çizgi kullanımının neden felaket olabileceğini kendiniz görebilirsiniz:

Bunun gibi basit bir helloWorld.cpp programı derlemeyi deneyin:

g++ -E helloWorld.cpp

Arka planda olan her şeyi göreceksiniz. İşte bir pasaj:

   ios_base::iostate __err = ios_base::iostate(ios_base::goodbit);
   try
     {
       __streambuf_type* __sb = this->rdbuf();
       if (__sb)
  {
    if (__sb->pubsync() == -1)
      __err |= ios_base::badbit;
    else
      __ret = 0;
  }

Çift alt çizgiyle kaç adın başladığını görebilirsiniz!

Ayrıca sanal üye işlevlerine bakarsanız, sınıfınızda bir veya daha fazla sanal üye işlevi kullandığınızda otomatik olarak oluşturulan sanal tablo için oluşturulan işaretçi * _vptr olduğunu göreceksiniz! Ama bu başka bir hikaye ...

Alt çizgi kullanırsanız, çatışma sorunlarıyla karşılaşabilirsiniz ve çok geç olana kadar buna neden olan hiçbir Fikri YOK OLACAKSINIZ.

Aslında _varkural C # veya C ++ değil VB'den gelir (m _, ... başka bir şeydir).

Bu, Özellikler bildirilirken VB'nin duyarsızlığının üstesinden gelmeye başladı.

Örneğin, böyle bir kod VB'de mümkün değildir userve Useraynı tanımlayıcı olarak kabul edilir.

Private user As String

Public Property User As String
  Get
    Return user
  End Get
  Set(ByVal Value As String)
    user = value
  End Set
End Property

Bunun üstesinden gelmek için, bazıları özel alana '_' eklemek için bir kural kullandı

Private _user As String

Public Property User As String
  Get
    Return _user
  End Get
  Set(ByVal Value As String)
    _user = value
  End Set
End Property

Birçok kural .Net için olduğundan ve C # et VB.NET kuralı arasında bir bütünlük sağlamak için, aynı yöntemi kullanırlar.

Söylediklerimin referansını buldum: http://10rem.net/articles/net-naming-conventions-and-programming-standards---best-practices

Öncü Alt Çizgili Deve Kılıfı. VB.NET'te her zaman "Korumalı" veya "Özel" olarak belirtin, "Dim" kullanmayın. "M_" kullanımı, özellikten yalnızca duruma göre farklılık gösteren bir değişken adının kullanılması, özellikle uyumu engellediği için korunan değişkenlerle kullanılması ve VB.NET'te programladığınızda hayatınızı acı haline getirmesi için önerilmez. üyelerinize erişimci / mutator özelliklerinden farklı bir ad vermeniz gerekir. Buradaki tüm öğeler arasında, en başta gelen alt çizgi gerçekten tartışmalı tek konudur. Ben şahsen özel değişkenlerim için düz alt çizgi-deve durumda tercih ederim, böylece değişken isimlerini "bu" ile nitelemek zorunda değilim. bir adlandırma çarpışması yaşayacağım, inşaatçılar veya başka yerlerdeki parametrelerden ayırt etmek. VB.NET'in büyük / küçük harfe duyarsızlığı nedeniyle, erişimci özelliklerinizin alt çizgi hariç özel üye değişkenlerinizle aynı ada sahip olacağı için bu daha da önemlidir. M_ kadarıyla, gerçekten sadece estetik ile ilgili. Değişken adında bir delik varmış gibi ben (ve diğerleri) m_ çirkin buluyorum. Neredeyse saldırgan. VB6'da her zaman kullanıyordum, ancak bunun nedeni değişkenlerin önde gelen alt çizgileri olamazdı. Gittiğini görmek daha mutlu olamazdı. Microsoft, kodlarında her ikisi de yapmış olsalar bile, m_ (ve düz _) aleyhine önerir. Ayrıca, düz bir "m" ile önek eklenir. Tabii ki, esas olarak C # kodladıkları için, sadece özelliklerinden farklı olan özel üyelere sahip olabilirler. VB millet başka bir şey yapmak zorunda. Her dil için özel durumlar bulmaya çalışmak yerine, onu destekleyecek tüm diller için alt çizgiyi öneriyorum. Sınıfımın tamamen CLS uyumlu olmasını istiyorsam, herhangi bir C # korumalı üye değişkeni önekini bırakabilirim. Ancak uygulamada, potansiyel olarak korunan tüm üye değişkenleri gizli tuttuğum ve bunun yerine korumalı erişimciler ve mutasyon sağlayıcıları sağladığım için bu konuda asla endişelenmiyorum. Neden: Özetle, bu kural basittir (bir karakter), okunması kolaydır (gözünüz diğer önde gelen karakterler tarafından dikkati dağıtmaz) ve yordam düzeyinde değişkenler ve sınıf düzeyi özelliklerle çarpışmaları adlandırmayı başarıyla önler. Sınıf düzeyi özellikler . Bunu destekleyecek tüm diller için alt çizgiyi öneriyorum. Sınıfımın tamamen CLS uyumlu olmasını istiyorsam, herhangi bir C # korumalı üye değişkeni önekini bırakabilirim. Ancak uygulamada, potansiyel olarak korunan tüm üye değişkenleri gizli tuttuğum ve bunun yerine korumalı erişimciler ve mutasyon sağlayıcıları sağladığım için bu konuda asla endişelenmiyorum. Neden: Özetle, bu kural basittir (bir karakter), okunması kolaydır (gözünüz diğer önde gelen karakterler tarafından dikkati dağıtmaz) ve yordam düzeyinde değişkenler ve sınıf düzeyi özelliklerle çarpışmaları adlandırmayı başarıyla önler. Sınıf düzeyi özellikler . Bunu destekleyecek tüm diller için alt çizgiyi öneriyorum. Sınıfımın tamamen CLS uyumlu olmasını istiyorsam, herhangi bir C # korumalı üye değişkeni önekini bırakabilirim. Ancak uygulamada, potansiyel olarak korunan tüm üye değişkenleri gizli tuttuğum ve bunun yerine korumalı erişimciler ve mutasyon sağlayıcıları sağladığım için bu konuda asla endişelenmiyorum. Neden: Özetle, bu kural basittir (bir karakter), okunması kolaydır (gözünüz diğer önde gelen karakterler tarafından dikkati dağıtmaz) ve yordam düzeyinde değişkenler ve sınıf düzeyi özelliklerle çarpışmaları adlandırmayı başarıyla önler. Sınıf düzeyi özellikler . Potansiyel olarak korunan tüm üye değişkenleri gizli tuttuğum ve bunun yerine korumalı erişimciler ve mutantlar sağladığım için bu konuda hiç endişe etmem. Neden: Özetle, bu kural basittir (bir karakter), okunması kolaydır (gözünüz diğer önde gelen karakterler tarafından dikkati dağıtmaz) ve yordam düzeyinde değişkenler ve sınıf düzeyi özelliklerle çarpışmaları adlandırmayı başarıyla önler. Sınıf düzeyi özellikler . Potansiyel olarak korunan tüm üye değişkenleri gizli tuttuğum ve bunun yerine korumalı erişimciler ve mutantlar sağladığım için bu konuda hiç endişe etmem. Neden: Özetle, bu kural basittir (bir karakter), okunması kolaydır (gözünüz diğer önde gelen karakterler tarafından dikkati dağıtmaz) ve yordam düzeyinde değişkenler ve sınıf düzeyi özelliklerle çarpışmaları adlandırmayı başarıyla önler. Sınıf düzeyi özellikler .

İlk yorumcu (R Samuel Klatchko) başvuruda bulundu: C ++ tanımlayıcısında alt çizgi kullanma ile ilgili kurallar nelerdir? C ++ alt çizgisi ile ilgili soruyu cevaplar. Genel olarak, derleyicinizin uygulayıcısı için ayrıldığından, önde gelen bir alt çizgi kullanmanız gerekmez. Gördüğünüz kod _varmuhtemelen eski kod veya önde gelen alt çizgilerde kaşlarını çatmayan eski adlandırma sistemini kullanarak büyüyen biri tarafından yazılan koddur.

Diğer cevaplar durumu olarak, C ++ 'da sınıf üyesi değişkenlerini tanımlamak için kullanılır. Bununla birlikte, dekoratörler veya sözdizimi kadar özel bir anlamı yoktur. Eğer kullanmak istiyorsanız, derleyecektir.

C # tartışmasını başkalarına bırakacağım.

_var'ın bir anlamı yoktur ve yalnızca değişkenin özel üye değişkeni olduğunu ayırt etmeyi kolaylaştırır.

C ++ 'da, _var kuralını kullanmak kötü bir formdur, çünkü bir tanımlayıcının önünde alt çizginin kullanımını düzenleyen kurallar vardır. _var genel tanımlayıcı olarak ayrılırken, _Var (alt çizgi + büyük harf) her zaman ayrılır. Bu nedenle C ++ 'da var_ kuralını kullanan kişileri göreceksiniz.

Kendi kodlama kurallarınızı oluşturabilirsiniz. Ekibin geri kalanı için açık bir doküman yazmanız yeterli.

_Field kullanılması Intelilsense'in _ yazarak tüm sınıf değişkenlerini filtrelemesine yardımcı olur.

Genellikle Brad Adams Yönergeleri'ni izlerim , ancak alt çizgiyi kullanmamanızı önerir.

C # için Microsoft adlandırma standardı değişkenlerin ve parametrelerin IE: alt deve durum formunu kullanması gerektiğini söylüyor paramName. Alanlar aynı formu takip etmekten başka birçok takım netlik artırmak için bir alt çizgi öneki için çağrı nedenle bu belirsiz koda sebep olabilir için standart ayrıca çağırır IE: _fieldName .

C # ile, Microsoft Framework Tasarım Yönergeleri genel üyeler için alt çizgi karakterini kullanmamanızı önerir . İçin özel üyeleri, alt kullanmak için OK bulunmaktadır. Aslında, Jeffrey Richter (genellikle kılavuzlarda belirtilir) örneğin m_ ve özel statik üyeler için bir "s_" kullanır.

Şahsen, özel üyelerimi işaretlemek için sadece _ kullanıyorum. Yalnızca m. .

Sınıflarımın üye değişkenleri için _var adlandırma kullanıyorum. Yapmamın 2 ana nedeni var:

1) Daha sonra kodumu okurken sınıf değişkenlerini ve yerel fonksiyon değişkenlerini takip etmeme yardımcı oluyor.

2) Bir sınıf değişkeni ararken Intellisense'de (veya başka bir kod tamamlama sisteminde) yardımcı olur. Sadece ilk karakterin bilinmesi, mevcut değişkenler ve yöntemler listesi aracılığıyla filtrelemeye yardımcı olur.

C ve C ++ dilleri söz konusu olduğunda, adın alt çizgisinin (başlangıç, orta veya bitiş) özel bir anlamı yoktur. Bu sadece geçerli bir değişken ismi karakteri. "Sözleşmeler", bir kodlama topluluğu içindeki kodlama uygulamalarından gelir.

Yukarıda çeşitli örneklerle zaten belirtildiği gibi, başlangıçta _, C ++ 'da bir sınıfın özel veya korunan üyeleri anlamına gelebilir.

Eğlenceli trivia olabilecek bazı tarihler vereyim. UNIX'te, çekirdek işlevini kullanıcı alanına göstermek istediğiniz bir çekirdek C kitaplığı işleviniz ve bir çekirdek arka ucunuz varsa, _, başka bir şey yapmadan doğrudan çekirdek işlevini çağıran işlev saplamasının önüne yapışır. Bunun en ünlü ve tanıdık örneği BSD ve SysV türü çekirdekler altında exit () vs _exit () şeklindedir: Orada, exit (), çekirdeğin çıkış hizmetini çağırmadan önce kullanıcı-alanı işlerini yaparken, _exit sadece çekirdeğin çıkış hizmetiyle eşleşir.

Yani _ "yerel" şeyler için bu durumda yerel makine-yerel olmak için kullanıldı. Genellikle _functions () taşınabilir değildi. Bu, çeşitli platformlarda aynı davranışı beklememelisiniz.

Şimdi _ gibi değişken isimlerinde, örneğin

int _foo;

Psikolojik olarak, _, başlangıçta yazmak zorunda kalan tuhaf bir şeydir. Bu nedenle, başka bir şeyle çarpışma şansı daha az olacak bir değişken adı oluşturmak istiyorsanız, özellikle istediğiniz işlemci öncesi ikamelerle uğraşırken _ kullanımını düşünün.

Temel tavsiyem her zaman kodlama topluluğunuzun kurallarına uymaktır, böylece daha etkili bir şekilde işbirliği yapabilirsiniz.

Basitçe sınıfta bir üye alanı olduğu anlamına gelir.

Belirli bir tek adlandırma kuralı yok, ancak bunu özel üyeler için gördüm.

Birçok kişi özel alanların altını çizerek altçizgi ister. Bu sadece bir adlandırma kuralıdır.

C # 'resmi' adlandırma kuralları özel alanlar için basit küçük isimler (alt çizgi yok) reçete.

Alt çizgiler çok yaygın olarak kullanılmasına rağmen, C ++ için standart kuralların farkında değilim.

Bazı programcıların sınıfın bir üyesini veya başka bir değişken türünü (parametreler, işleve yerel, vb.) Manipüle ederken bunu açıkça belirtmek için kullandığı bir kuraldır. Üye değişkenleri için de yaygın olarak kullanılan diğer bir kural da ismin önüne 'm_' önekini eklemektir.

Her neyse, bunlar sadece sözleşmelerdir ve hepsi için tek bir kaynak bulamazsınız. Bunlar bir stil meselesidir ve her programlama ekibi, proje veya şirketin kendine ait (hatta hiç yoktur).

C # 'da kullanmak için tamamen yasal bir neden var: kod VB.NET'ten de genişletilebilir olması gerekiyorsa. (Aksi halde yapmazdım.)

VB.NET büyük / küçük harfe duyarlı olmadığından, korunan fieldüyeye bu kodda erişmenin basit bir yolu yoktur :

public class CSharpClass
{
    protected int field;
    public int Field { get { return field; } }
}

Örneğin bu, alana değil mülk alıcısına erişir:

Public Class VBClass
    Inherits CSharpClass

    Function Test() As Integer
        Return Field
    End Function

End Class

Heck, fieldküçük harfle bile yazamıyorum - VS 2010 düzeltmeye devam ediyor.

VB.NET'te türetilmiş sınıflara kolayca erişilebilmesi için, bir başka adlandırma kuralı bulmak gerekir. Bir alt çizginin ön eki muhtemelen bunların en az müdahaleci ve en "tarihsel olarak kabul edilen" idir.

Şimdi this.foobarbaz'da olduğu gibi "this" kullanarak gösterim C # sınıfı üye değişkenleri için kabul edilebilir. Eski "m_" veya sadece "__" gösteriminin yerini alır. Kodun daha okunabilir olmasını sağlar, çünkü referansta ne olduğuna şüphe yoktur.

Deneyimlerime göre (kesinlikle sınırlı), alt çizgi özel üye değişkeni olduğunu gösterecektir. Gollum'un dediği gibi, bu takıma bağlı olacak.

Eski soru, yeni cevap (C #).

C # için alt çizgilerin bir başka kullanımı ASP NET Core'un DI (bağımlılık enjeksiyonu). readonlyİnşaat sırasında enjekte edilen arayüze atanan bir sınıfın özel değişkenleri bir alt çizgi ile başlamalıdır. Sanırım bir sınıfın her özel üyesi için alt çizgi kullanıp kullanmayacağına dair bir tartışma (Microsoft'un kendisini takip etmesine rağmen) ama bu kesin.

private readonly ILogger<MyDependency> _logger;

public MyDependency(ILogger<MyDependency> logger)
{
    _logger = logger;
}

Bunun gibi bir adlandırma kuralı, özellikle kendi kodunuz olmayan kodu okurken yararlıdır. Güçlü bir adlandırma kuralı, belirli bir üyenin nerede tanımlandığını, ne tür bir üye olduğunu vb. Belirtmeye yardımcı olur. Çoğu geliştirme ekibi basit bir adlandırma kuralını benimser ve üye alanlarını alt çizgi ( _fieldName) ile önek olarak ekler . Geçmişte, C # için aşağıdaki adlandırma kuralını kullandım (Reflektör ile görülebilen .NET çerçeve kodu için Microsofts kurallarına dayanmaktadır):

Örnek Alanı: m_fieldName
Statik Alan: s_fieldName
Genel / Korumalı / Dahili Üye: PascalCasedName ()
Özel Üye: camelCasedName ()

Bu, insanların tanıdık olmayan kodu çok hızlı okurken üyelerin yapısını, kullanımını, erişilebilirliğini ve yerini anlamalarına yardımcı olur.