Açıkça yapmazsam C ++ sınıf üyeleri nasıl başlatılır?

Ben özel Eklenmiþ sahip bir sınıf olduğunu varsayalım ptr, name, pname, rname, crnameve age. Onları kendim başlatmazsam ne olur? İşte bir örnek:

class Example {
    private:
        int *ptr;
        string name;
        string *pname;
        string &rname;
        const string &crname;
        int age;

    public:
        Example() {}
};

Ve sonra yaparım:

int main() {
    Example ex;
}

Üyeler ex'de nasıl başlatılır? İşaretçilerle ne olur? Do stringve intalmak varsayılan kurucular ile 0-intialized string()ve int()? Referans üye ne olacak? Peki ya const referansları?

Başka ne bilmeliyim?

Herkes bu vakaları kapsayan bir öğretici biliyor mu? Belki bazı kitaplarda? Üniversite kütüphanesinde birçok C ++ kitabına erişimim var.

Daha iyi (hatasız) programlar yazabilmek için öğrenmek istiyorum. Herhangi bir geri bildirim yardımcı olacaktır!

Açık başlatma yerine, sınıflardaki üyelerin başlatılması, işlevlerdeki yerel değişkenlerin başlatılmasıyla aynı şekilde çalışır.

İçin nesneler , varsayılan kurucu denir. Örneğin std::string, varsayılan kurucu onu boş bir dizeye ayarlar. Nesnenin sınıfının varsayılan bir yapıcısı yoksa, açıkça başlatmazsanız derleme hatası olur.

İçin basit türler (işaretçiler, ints, vb), onlar vardır değil başlatıldı - onlar keyfi önemsiz önceden o hafıza yerde olmak ne oldu içerirler.

İçin referanslar (örn std::string&), öyle yasadışı bunları başlatmak için değil, ve derleyici şikayet ve böyle bir kod derlemeye reddeder. Referanslar her zaman başlatılmalıdır.

Dolayısıyla, özel durumunuzda, açıkça başlatılmamışlarsa:

    int *ptr;  // Contains junk
    string name;  // Empty string
    string *pname;  // Contains junk
    string &rname;  // Compile error
    const string &crname;  // Compile error
    int age;  // Contains junk

Önce mem-başlatıcı listesinin ne olduğunu açıklayayım . Bir mem-başlatıcı-listesi , her mem-başlatıcısının bir üye adı ve ardından bir ifade listesi ve ardından a, virgülle ayrılmış bir mem-başlatıcıları listesidir . İfadesi listesi üyesi oluşturulur nasıl. Örneğin,()

static const char s_str[] = "bodacydo";
class Example
{
private:
    int *ptr;
    string name;
    string *pname;
    string &rname;
    const string &crname;
    int age;

public:
    Example()
        : name(s_str, s_str + 8), rname(name), crname(name), age(-4)
    {
    }
};

Mem-başlatıcı-liste kullanıcı tarafından sağlanan, hiç argümanlar yapıcısı taşımaktadır name(s_str, s_str + 8), rname(name), crname(name), age(-4). Bu mem-başlatıcı listesi , nameüyenin iki giriş yineleyicisi alan std::stringyapıcı tarafından başlatıldığı , rnameüye bir referansla başlatılır name, crnameüye bir const referansı ile başlatılır nameve ageüye değerle başlatılır -4.

Her kurucunun kendi mem-başlatıcı listesi vardır ve üyeler yalnızca önceden belirlenmiş bir sırayla (temel olarak üyelerin sınıfta beyan edildikleri sıraya göre) başlatılabilir. Bu nedenle, üyeleri Exampletek amacıyla başlatıldı: ptr, name, pname, rname, crname, ve age.

Bir üyenin mem başlatıcısı belirtmediğinizde , C ++ standardı şöyle der:

Varlık, sınıf ... türünde statik olmayan bir veri üyesiyse, varlık varsayılan olarak başlatılır (8.5). ... Aksi takdirde varlık başlatılmaz.

Burada, namesınıf türünde statik olmayan bir veri üyesi olduğu için name, mem başlatıcı listesinde herhangi bir başlatıcı belirtilmemişse varsayılan olarak başlatılır . Diğer tüm üyelerin Examplesınıf türü yoktur, bu nedenle başlatılmazlar.

Standart başlatılmadıklarını söylediğinde, bu onların herhangi bir değere sahip olabileceği anlamına gelir . Dolayısıyla, yukarıdaki kod başlatılmadığından pname, herhangi bir şey olabilir.

Referansların her zaman başlatılması gereken kural gibi başka kurallara uymanız gerektiğini unutmayın. Referansları başlatmamak bir derleyici hatasıdır.

Veri üyelerini, bildirdiğiniz noktada da başlatabilirsiniz:

class another_example{
public:
    another_example();
    ~another_example();
private:
    int m_iInteger=10;
    double m_dDouble=10.765;
};

Bu formu hemen hemen tamamen kullanıyorum, ancak bazı insanların onu 'kötü form' olarak gördüğünü okudum, ancak belki de son zamanlarda tanıtıldığı için - C ++ 11'de düşünüyorum. Bana göre daha mantıklı.

Yeni kuralların bir diğer yararlı yönü, kendileri sınıf olan veri üyelerinin nasıl başlatılacağıdır. Diyelim ki CDynamicStringdize işlemeyi içine alan bir sınıf. Başlangıç ​​değerini belirlemenizi sağlayan bir yapıcıya sahiptir CDynamicString(wchat_t* pstrInitialString). Bu sınıfı başka bir sınıfın içindeki bir veri üyesi olarak kullanabilirsiniz - bu durumda bir posta adresini depolayan bir Windows kayıt defteri değerini kapsayan bir sınıf. Parantez kullandığınız kayıt defteri anahtarının adını 'sabit kodlamak' için:

class Registry_Entry{
public:
    Registry_Entry();
    ~Registry_Entry();
    Commit();//Writes data to registry.
    Retrieve();//Reads data from registry;
private:
    CDynamicString m_cKeyName{L"Postal Address"};
    CDynamicString m_cAddress;
};

Gerçek posta adresini tutan ikinci dize sınıfının bir başlatıcısı olmadığına dikkat edin, bu nedenle varsayılan kurucusu oluşturma sırasında çağrılır - belki de otomatik olarak boş bir dizeye ayarlanır.

Örnek sınıf yığın üzerinde başlatılırsa, başlatılmamış skaler üyelerin içeriği rasgele ve tanımsızdır.

Genel bir örnek için, başlatılmamış skaler üyeler sıfırlanır.

Kendileri sınıf örneği olan üyeler için varsayılan kurucuları çağrılır, böylece dize nesneniz başlatılır.

• int *ptr; // başlatılmamış işaretçi (veya global ise sıfırlanmış)
• string name; // kurucu çağrıldı, boş dize ile başlatıldı
• string *pname; // başlatılmamış işaretçi (veya global ise sıfırlanmış)
• string &rname; // bunu başlatamazsanız derleme hatası
• const string &crname; // bunu başlatamazsanız derleme hatası
• int age; // skaler değer, başlatılmamış ve rastgele (veya global ise sıfırlanmış)

Başlatılmamış statik olmayan üyeler rastgele veriler içerir. Aslında, sadece atandıkları bellek konumu değerine sahip olacaklar.

Tabii ki nesne parametreleri için (gibi string) nesnenin yapıcısı varsayılan bir başlatma yapabilir.

Örneğinizde:

int *ptr; // will point to a random memory location
string name; // empty string (due to string's default costructor)
string *pname; // will point to a random memory location
string &rname; // it would't compile
const string &crname; // it would't compile
int age; // random value

Bir kurucuya sahip üyelerin varsayılan kurucuları başlatma için çağrılacaktır.

Diğer türlerin içeriğine güvenemezsiniz.

Yığın üzerindeyse, kendi kurucuları olmayan başlatılmamış üyelerin içeriği rastgele ve tanımsız olacaktır. Küresel olsa bile, bunların sıfırlanmasına güvenmek kötü bir fikir olacaktır. Yığında olsun ya da olmasın, bir üyenin kendi yapıcısı varsa, onu başlatmak için çağrılacaktır.

Yani, * pname dizeniz varsa, işaretçi rastgele önemsiz içerir. ancak dize adı için, dize için varsayılan yapıcı çağrılır ve size boş bir dize verilir. Referans türü değişkenleriniz için emin değilim, ancak muhtemelen bazı rastgele bellek yığınlarına bir referans olacaktır.

Sınıfın nasıl inşa edildiğine bağlıdır

Bu soruyu cevaplamak, C ++ dil standardında büyük bir anahtar durum ifadesini ve sadece ölümlülerin sezgi alması zor olanı anlamaya geliyor.

İşin ne kadar zor olduğuna dair basit bir örnek olarak:

main.cpp

#include <cassert>

int main() {
    struct C { int i; };

    // This syntax is called "default initialization"
    C a;
    // i undefined

    // This syntax is called "value initialization"
    C b{};
    assert(b.i == 0);
}

Varsayılan başlatma işleminde şu konumdan başlıyorsunuz: https://en.cppreference.com/w/cpp/language/default_initialization "Varsayılan başlatmanın etkileri" bölümüne gideriz ve vaka bildirimini başlatırız:

• "Eğer T POD değilse ": hayır (POD'un tanımı kendi başına büyük bir anahtar deyimidir)
• "T bir dizi türüyse": hayır
• "aksi halde hiçbir şey yapılmaz": bu nedenle tanımlanmamış bir değerle bırakılır

Daha sonra, birisi değer atamaya karar verirse, https://en.cppreference.com/w/cpp/language/value_initialization "Değer başlatmanın etkileri" olur ve vaka bildirimini başlatırız:

• "T varsayılan kurucu olmayan veya kullanıcı tarafından sağlanan veya silinmiş varsayılan kurucu bulunan bir sınıf tipiyse": durum böyle değil. Şimdi 20 dakika harcayacaksınız.
  • örtük olarak tanımlanmış bir varsayılan kurucumuz var (özellikle başka kurucu tanımlanmadığı için)
  • kullanıcı tarafından sağlanmaz (örtülü olarak tanımlanır)
  • silinmez ( = delete)
• "T, kullanıcı tarafından sağlanan veya silinmeyen varsayılan oluşturucuya sahip bir sınıf türüyse": Evet
  • "nesne sıfırdan başlatılır ve sonra önemsiz olmayan bir varsayılan kurucuya sahipse varsayılan olarak başlatılır": önemsiz olmayan bir kurucu yok, sadece sıfırla başlatır. "Sıfır başlangıç" tanımı en azından basittir ve beklediğinizi yapar: https://en.cppreference.com/w/cpp/language/zero_initialization

Bu yüzden asla "örtük" sıfır başlatmaya güvenmemenizi şiddetle tavsiye ederim. Güçlü performans nedenleri olmadıkça, ya tanımladıysanız kurucuda ya da toplam başlatma kullanarak her şeyi açıkça başlatın. Aksi takdirde gelecekteki geliştiriciler için işleri çok riskli hale getirirsiniz.