İşaretçi ve Referans

Bir işleve çalışmak için orijinal değişken verirken daha iyi uygulama ne olabilir:

unsigned long x = 4;

void func1(unsigned long& val) {
     val = 5;            
}
func1(x);

veya:

void func2(unsigned long* val) {
     *val = 5;
}
func2(&x);

IOW: Birini diğerinin üzerine seçmek için bir sebep var mı?

Temel kuralım:

İşaretçilerle onlarla aritmetik yapmak istiyorsanız (örneğin, bir dizide adım atmak için işaretçi adresini artırma) veya hiç NULL-işaretçisi geçmeniz gerektiğinde işaretçileri kullanın.

Aksi takdirde referans kullanın.

Kodlama yönergelerini çağıran aşağıdaki işlevi oluşturmaktan gerçekten fayda sağlayacağınızı düşünüyorum:

1. Tüm diğer yerlerde olduğu gibi, her zaman const-doğru olun.

   • Not: Bu, diğer şeylerin yanı sıra, yalnızca çıkış değerlerinin (madde 3'e bakın) ve değerden geçen değerlerin (madde 4'e bakın) belirleyiciden yoksun olabileceği anlamına gelir const.

2. Yalnızca 0 / NULL değeri geçerli bağlamda geçerli bir girdi ise, işaretçiyi yalnızca işaretçi olarak iletin.

   • Gerekçe 1: Arayan olarak gördüğünüz her şeyin kullanılabilir durumda olması gerektiğini görürsünüz .

   • Gerekçe 2: As denilen İçinde gelirse biliyoruz olan kullanılabilir bir durumda. Bu nedenle, bu değer için NULL denetim veya hata işlemeye gerek yoktur.

   • Gerekçe 3: Gerekçeler 1 ve 2 derleyici tarafından uygulanacaktır . Mümkünse her zaman hataları derleme zamanında yakalayın.

3. Bir işlev bağımsız değişkeni bir çıkış değeriyse, başvuru ile iletin.

   • Gerekçe: 2. maddeyi kırmak istemiyoruz ...

4. Yalnızca değerin bir POD ( Düz eski Veri Yapısı ) veya yeterince küçük (bellek açısından) veya başka şekillerde kopyalamak için yeterince ucuz (zaman açısından) olması durumunda "sabit referansla geçiş" üzerinden "değere göre geç" seçeneğini belirleyin.

   • Gerekçe: Gereksiz kopyalardan kaçının.
   • Not: yeterince küçük ve yeterince ucuz mutlak ölçülebilir değildir.

Bu nihayetinde özneldir. Şimdiye kadar tartışma faydalıdır, ancak bunun doğru veya kesin bir cevabı olduğunu düşünmüyorum. Çok şey stil yönergelerine ve o sırada ihtiyaçlarınıza bağlı olacaktır.

Bir işaretçi ile bazı farklı yetenekler (bir şeyin NULL olup olmadığı) olsa da, bir çıkış parametresi için en büyük pratik fark tamamen sözdizimidir. Örneğin, Google'ın C ++ Stil Kılavuzu ( https://google.github.io/styleguide/cppguide.html#Reference_Arguments ) yalnızca çıktı parametreleri için işaretçiler zorunlu kılar ve yalnızca const referanslarına izin verir. Akıl yürütme okunabilirliktir: değer sözdizimine sahip bir şeyin işaretçi anlamsal anlamı olmamalıdır. Bunun mutlaka doğru ya da yanlış olduğunu öne sürmüyorum, ama bence buradaki mesele, doğruluk değil, bir stil meselesi.

Değişkenin değerini değiştirecekseniz bir işaretçi geçmelisiniz. Teknik olarak bir referans veya işaretçi geçirme aynı olsa da, kullanım durumunuzda bir işaretçiyi iletmek, değerin işlev tarafından değiştirileceği gerçeğini "tanıdığı" için daha okunabilir.

Bir değerin yokluğunu belirtmeniz gerekebilecek bir parametreniz varsa, parametreyi bir işaretçi değeri yapmak ve NULL olarak iletmek yaygın bir uygulamadır.

Çoğu durumda (güvenlik açısından) daha iyi bir çözüm, boost :: isteğe bağlı kullanmaktır . Bu, isteğe bağlı değerleri referans olarak ve bir dönüş değeri olarak iletmenizi sağlar.

// Sample method using optional as input parameter
void PrintOptional(const boost::optional<std::string>& optional_str)
{
    if (optional_str)
    {
       cout << *optional_str << std::endl;
    }
    else
    {
       cout << "(no string)" << std::endl;
    }
}

// Sample method using optional as return value
boost::optional<int> ReturnOptional(bool return_nothing)
{
    if (return_nothing)
    {
       return boost::optional<int>();
    }

    return boost::optional<int>(42);
}

Mümkün olduğunda bir referans kullanın, gerektiğinde bir işaretçi kullanın. Gönderen C ++ SSS: "Ben işaretçileri kullanmak gerekirken zaman referansları kullanın ve ki?"

İşaretçiler

• İşaretçi, bellek adresini tutan bir değişkendir.
• İşaretçi bildirimi temel tür, * ve değişken adından oluşur.
• Bir işaretçi ömür boyu herhangi bir sayıda değişkeni gösterebilir

• Şu anda geçerli bir bellek konumuna işaret etmeyen bir işaretçiye null değeri verilir (Sıfır olan)

  BaseType* ptrBaseType;
  BaseType objBaseType;
  ptrBaseType = &objBaseType;

• &, İşleneninin bellek adresini döndüren tekli bir operatördür.

• Dereferencing operatörü (*), işaretçinin işaret ettiği değişkende depolanan değere erişmek için kullanılır.

     int nVar = 7;
     int* ptrVar = &nVar;
     int nVar2 = *ptrVar;

Referans

• Bir başvuru (&), mevcut bir değişkenin takma adı gibidir.

• Bir başvuru (&), otomatik olarak kaydı silinen sabit bir işaretçi gibidir.

• Genellikle işlev bağımsız değişken listeleri ve işlev döndürme değerleri için kullanılır.

• Bir referans oluşturulduğunda başlatılmalıdır.

• Bir nesneye referans başlatıldıktan sonra, başka bir nesneye atıfta bulunmak için değiştirilemez.

• NULL referansınız olamaz.

• Bir const referansı, bir const int. Sabit değere sahip geçici bir değişkenle yapılır

  int i = 3;    //integer declaration
  int * pi = &i;    //pi points to the integer i
  int& ri = i;    //ri is refers to integer i – creation of reference and initialization

Referans, örtük bir işaretçi. Temel olarak referansın işaret ettiği değeri değiştirebilirsiniz, ancak referansı başka bir şeye işaret edecek şekilde değiştiremezsiniz. Bu yüzden 2 sentim, sadece bir parametrenin değerini değiştirmek istiyorsanız, referans olarak geçmesi, ancak parametreyi farklı bir nesneye işaret edecek şekilde değiştirmeniz gerekiyorsa, bir işaretçi kullanarak geçirin.

C # 's out anahtar sözcüğünü düşünün. Derleyici, zaten olup olmadıklarını bilmesine rağmen, out anahtar sözcüğünü herhangi bir bağımsız değişkene uygulamak için bir yöntemin aranmasını gerektirir. Bu, okunabilirliği artırmayı amaçlamaktadır. Her ne kadar modern IDE'lerde bunun sözdizimi (veya anlamsal) vurgulama için bir iş olduğunu düşünmeye meyilliyim.

İçeriği değiştirmek / saklamak istemeniz için bir neden olmadığı sürece const referansı ile iletin.

Bu çoğu durumda en etkili yöntem olacaktır.

Değiştirmek istemediğiniz her parametrede const kullandığınızdan emin olun, çünkü bu sadece işlevde aptalca bir şey yapmaktan korumakla kalmaz, aynı zamanda diğer kullanıcılara işlevin iletilen değerlere ne yaptığını iyi bir şekilde gösterir. Bu sadece işaret edilen şeyi değiştirmek istediğinizde bir işaretçi const yapmayı içerir ...

İşaretçiler:

• Atanabilir nullptr(veyaNULL ).
• Çağrı sitesinde şunu kullanmalısınız: & türünüz bir işaretçinin kendisi değilse, nesneyi açıkça değiştirdiğinizde kullanmanız gerekir.
• İşaretçiler geri tepebilir.

Referanslar:

• Boş olamaz.
• Bağlandıktan sonra değişemez.
• Arayanların açıkça kullanmasına gerek yoktur &. Parametrenizin değiştirilip değiştirilmediğini görmek için işlevin uygulanmasına gitmeniz gerektiğinden bu bazen kötü kabul edilir.

Referans, işaretçiye benzer, ancak referans tarafından belirtilen değere erişmek için ∗ önekini kullanmanız gerekmez. Ayrıca, başlatıldıktan sonra farklı bir nesneye gönderme yapmak için başvuru yapılamaz.

Referanslar özellikle işlev bağımsız değişkenlerini belirtmek için kullanışlıdır.

daha fazla bilgi için bkz. "Bjarne Stroustrup" dan "C ++ Turu" (2014) Sayfa 11-12