“#Define me (* this)” tanımlamak iyi bir fikir mi?

Bu makro bazı genel üstbilgilerde veya daha iyisi bir derleyici komut satırı parametresi olarak tanımlanabilir:

#define me (*this)

Ve bazı kullanım örnekleri:

some_header.h:

inline void Update()
{
    /* ... */
}

main.cpp:

#include "some_header.h"

class A {
public:
    void SetX(int x)
    {
        me.x = x;   
        me.Update(); 
    }

    void SomeOtherFunction()
    {
        ::Update();
    }

    /*
        100 or more lines
        ... 
    */

    void Update()
    {
        // ... 
    }

    int x;  
};

Bir sınıf üyesine eriştiğimde bir sınıf yönteminde her zaman kullanıyorum meve her zaman kullandığım bir genel tanımlayıcıya erişiyorum ::. Bu, kodu tanımayan okuyucuya (muhtemelen birkaç ay sonra kendim) başka bir yere bakmaya gerek kalmadan erişilenlere ilişkin yerelleştirilmiş bilgiler verir. Ben tanımlamak istiyorum meçünkü this->her yerde çok gürültülü ve çirkin kullanarak bulmak . Ancak #define me (*this)iyi bir C ++ uygulaması olarak düşünülebilir mi? meMakro ile ilgili bazı pratik sorunlu noktalar var mı? Ve eğer C ++ programcısı olarak memakro kullanarak bazı kodların okuyucu olacak , ister misiniz ister misiniz?

Düzenleme: Çünkü birçok kişi meaçıkça kullanarak tam tersi değil , ama genellikle açık tam aksine. Bence "bu her yerde açık" ne faydaları net olmayabilir.

"Bunu her yerde açıkça" yapmanın faydaları nelerdir?

• Kodun bir okuyucusu olarak neye erişildiğine dair kesinliğe sahipsiniz ve eriştiğinizi düşündüğünüze gerçekten erişilen, bazı uzak kodlarda doğrulamadan farklı şeylere konsantre olabilirsiniz.
• Arama işlevini daha spesifik olarak kullanabilirsiniz. " this->x" Araması , size yalnızca " x" aramasından daha fazla aranan sonuçlar verebilir
• Bir üyeyi sildiğinizde veya yeniden adlandırdığınızda, derleyici bu üyenin kullanıldığı yerlerde size güvenilir bir şekilde bildirim gönderir. (Bazı global işlevler aynı ada sahip olabilir ve açık bir şekilde kullanmıyorsanız hata sunabilirsiniz.
• Kodu yeniden düzenlerken ve üyeden üye olmayan bir işlev yaptığınızda (daha iyi kapsülleme yapmak için) açık bir şekilde bu, düzenlemeniz gereken yeri gösterir ve bunu üye olmayan işlev parametresi olarak verilen sınıf örneğine kolayca işaretçiyle değiştirebilirsiniz.
• Genellikle kodu değiştirirken, bunu açıkça kullanmadığınızda, bunu her yerde açıkça kullandığınızdan daha fazla olasılık vardır.
• Açıkça dışarıdan üye ( object.membervs object.m_member) atarken açık "m_" den daha az gürültülü (bu noktayı tespit etmek için @Kaz sayesinde)
• Bu açıkça tüm üyeler - öznitelikler ve yöntemler için evrensel olarak sorunu çözerken, “m_” veya diğer önek pratik olarak yalnızca öznitelikler için kullanılabilir.

Bu listeyi cilalamak ve genişletmek, diğer avantajları biliyor musunuz ve bunu her yerde açıklamak için vakalar kullanmak istiyorsanız bana bildirin .

Hayır öyle değil.

Daha yeşil meralara gittikten uzun yıl sonra kodunuzu koruyacak programcıya dikkat edin ve kullandığınız dilin ortak kurallarına uyun. C ++ 'da neredeyse hiç yazmak zorunda kalmazsınız this, çünkü sınıf sembol çözünürlük sırasına dahil edilir ve sınıf kapsamında bir sembol this->bulunduğunda ima edilir. Yani herkesin yaptığı gibi yazmayın.

Sık sık hangi sembollerin sınıf kapsamından geldiğini karıştırırsanız, olağan yaklaşım üyeler için ortak adlandırma modeli kullanmaktır (alanlar ve bazen özel yöntemler; genel yöntemler için kullanıldığını görmedim). Ortak olanlar ile son eklemeli içerir _veya önek m_veya m.

Böylece, yeni bir dil oluşturmak istiyorsunuz. Sonra bunu yapın ve C ++ sakatlamayın.

Bunu yapmamak için birkaç neden var:

1. Her normal kodlama standardı makrolardan kaçınmayı önerecektir ( işte nedeni budur )
2. Bu tür makrolarla kodu korumak daha zordur. C ++ 'da programlama yapan herkesin ne thisolduğunu bilir ve böyle bir makro ekleyerek aslında yeni bir anahtar kelime eklersiniz. Ya herkes sevdiği bir şeyi tanıtırsa? Kod nasıl olurdu?
3. Bazı özel durumlar dışında kullanmamalısınız (*this).veya hiç kullanmamalısınız this->( bu cevaba bakın ve "this->" için arama yapın)

Kodunuz, #define R returngerçek kodda gördüğüm koddan farklı değil . Nedeni? Daha az yazarak!

Konudan biraz uzaklaşıyorum, ama burada 3. noktaya genişleyeceğim (kullanmayın (*this).veya this->bir sınıfta).

Her şeyden önce, (*this).ya this->da nesnenin üye değişkenlerine ya da işlevlerine erişmek için kullanılır. Kullanmak anlamsızdır ve daha fazla yazım anlamına gelir. Ayrıca, daha fazla metin olduğu için bu kodu okumak daha zordur. Bu, daha zor bakım anlamına gelir.

Peki, kullanmanız gereken durumlar this->nelerdir?

(a) Argümanın adının talihsiz seçimi.

Bu örnekte, this->bağımsız değişken üye değişkeniyle aynı ada sahip olduğundan gereklidir:

struct A {
  int v;
  void foo( int v ) {
    this->v =v;
  }
};

(b) şablonlar ve miras ile uğraşırken (bkz bu )

Bu örnek derlenemeyecektir, çünkü derleyici hangi isme verişmek için adlandırılmış olduğunu bilmiyor .

template< typename T >
struct A {
  A(const T& vValue):v(vValue){}

  T v;
};

template< typename T >
struct B : A<T>
{
    B(const T& vValue):A<T>(vValue){}

    void foo( const T & newV ) {
      v = newV;
    }
};

Bunu yapmamanızı öneririm. Bu, bunu gördüğünde makronuza aşina olmayan bir okuyucuya büyük bir " WTF " kazandırır. Genel kabul görmüş olanların üzerinde gerçek bir ihtiyaç olmaksızın "yeni sözleşmeler" icat edildiğinde kod daha okunabilir hale gelmez.

bunu kullanmak her yerde çok gürültülü ve çirkin

Belki size anahtar kelime me(Visual Basic, sanırım?) Kullanarak bir çok programlama yaptığınız için böyle görünebilir . Ama aslında bu sadece alışkın olma meselesi - this->oldukça kısa ve deneyimli C ++ programcılarının çoğunun sizin görüşünüze katılmayacağını düşünüyorum. Ve yukarıdaki durumda ne kullanımında this->veya kullanımına meuygun - Eğer üye fonksiyonların içinde veri üyeleri erişirken dışarı bu anahtar kelimeleri bırakarak dağınıklığı az miktarda olsun.

Özel üye değişkenlerinizin yerel değişkenlerden ayırt edilmesini istiyorsanız, m_önek olarak bir şey bağlantısı veya onlara bir sonek olarak alt çizgi ekleyin (ancak burada da görebileceğiniz gibi , bu sözleşme bile birçok kişi için "çok gürültülü").

Lütfen yapma! Yazarak kaydetmek için her yerde makrolar nerede büyük bir kod tabanı ile baş etmeye çalışıyorum. Bunu bana yeniden tanımlamanın kötü yanı, ön işlemcinin, kapsamda olmadığı / uygulanmadığı durumlarda bile her yerde onun yerini alacağıdır, örneğin tek başına bir işlev, çalışma arkadaşınızın başka bir yerde bana çağrılan yerel bir değişkeni olabilir. hata ayıklamaktan mutlu olmayacak ... Sonunda tüm kapsamlarda kullanamayacağınız makrolar var.

HAYIR!

# Eğer birileri o başlığı içeriyorsa, hilenizi bilmeden ortaya çıkacak karışıklığı hayal edin ve dosyalarının başka bir yerinde "ben" adı verilen bir değişken veya işlev varsa. Yazdırılamaz hata mesajı ne olursa olsun korkunç bir şekilde karışırlardı.