'Mutable' anahtar sözcüğünün değişkenin bir const işlevi tarafından değiştirilmesine izin vermekten başka bir amacı var mı?

Bir süre önce bir sınıfın üye değişkenini mutableanahtar kelimeyle işaretleyen bazı kodlarla karşılaştım . Görebildiğim kadarıyla basitçe bir constyöntemde bir değişkeni değiştirmek için izin verir :

class Foo  
{  
private:  
    mutable bool done_;  
public:  
    void doSomething() const { ...; done_ = true; }  
};

Bu, bu anahtar kelimenin tek kullanımı mı yoksa göze çarpandan daha fazlası mı var? O zamandan beri bu tekniği bir sınıfta kullandım, işlevlerin iplik güvenliği nedeniyle kilitlenmesine boost::mutexizin veren bir değişebilir olarak işaretledim const, ama dürüst olmak gerekirse, bir kesmek gibi geliyor.

Bitsel sabit ve mantıksal sabitin farklılaşmasına izin verir. Mantıksal sabit, bir nesnenin, kilitleme örneğiniz gibi, genel arabirimden görülebilecek şekilde değişmediği zamandır. Başka bir örnek, ilk istendiğinde bir değeri hesaplayan ve sonucu önbelleğe alan bir sınıftır.

C ++ 11 mutable, lambda'da değere göre yakalanan şeylerin değiştirilebilir olduğunu belirtmek için kullanılabildiğinden (varsayılan olarak değildir):

int x = 0;
auto f1 = [=]() mutable {x = 42;};  // OK
auto f2 = [=]()         {x = 42;};  // Error: a by-value capture cannot be modified in a non-mutable lambda

mutableAnahtar kelime delmek için bir yoldur constsize nesneleri üzerinde yayılacak peçe. Bir nesneye const referansınız veya işaretçiniz varsa, o nesneyi ne zaman ve nasıl işaretlendiği dışında hiçbir şekilde değiştiremezsiniz mutable.

Senin ile constbaşvuru veya pointer size kısıtlanır:

• yalnızca görünür veri üyeleri için okuma erişimi
• yalnızca olarak işaretlenmiş yöntemleri çağırma izni const.

mutableŞimdi yazabilir veya işaretlenmiş ayarlanan veri üyeleri böylece istisna yapar mutable. Dışarıdan görünen tek fark bu.

Dahili constolarak size göre görünen yöntemler işaretli veri üyelerine de yazabilir mutable. Esasen, yapı perdesi kapsamlı bir şekilde delinmiştir. Konsepti mutableyok etmediğinden constve yalnızca yararlı özel durumlarda kullanıldığından emin olmak tamamen API tasarımcısına bağlıdır . mutableAnahtar kelime bu özel durumlar tabi bunun nedeni açıkça işaretleri veri üye olur.

Uygulamada constkod tabanınız boyunca obsesif olarak kullanabilirsiniz (esasen kod tabanınızı const"hastalık" ile "enfekte etmek istersiniz ). Bu dünyada işaretçiler ve referanslar constçok az istisna dışında, akıl yürütmesi ve anlaması daha kolay olan kod verir. İlginç bir araştırma için "referans şeffaflığı" konusuna bakın.

mutableAnahtar kelime olmadan, sonunda const_castçeşitli yararlı özel durumları (önbellekleme, ref sayımı, hata ayıklama verileri, vb.) Ne yazık ki API istemcisini kullandığı nesnelerin / nesnelerin korunmasını yok etmeye zorladığı için const_castönemli ölçüde daha yıkıcıdır . Ek olarak yaygın yıkıma neden olur : bir sabit işaretçi veya başvuru oluşturmak, görünür üyelere serbest yazma ve yöntem çağırma erişimi sağlar. Bunun aksine , API tasarımcısının istisnalar üzerinde hassas bir kontrol gerçekleştirmesini gerektirir ve genellikle bu istisnalar özel veriler üzerinde çalışan yöntemlerde gizlenir .mutableconstconstconst_castmutableconstconst

(Not: Birkaç kez veri ve yöntem görünürlüğüne atıfta bulunuyorum . Burada tartışılan tamamen farklı bir nesne koruma türü olan, kamuya açık veya özel veya korumalı olarak işaretlenmiş üyelerden bahsediyorum .)

Boost :: mutex ile kullanımınız, tam olarak bu anahtar kelimenin amacıdır. Başka bir kullanım hızı hızlı erişim için dahili sonuç önbellekleme içindir.

Temel olarak 'mutable', nesnenin harici olarak görünür durumunu etkilemeyen herhangi bir sınıf niteliği için geçerlidir.

Sorunuzdaki örnek kodda, done_ değeri harici durumu etkiliyorsa, mutable uygun olmayabilir, ... Bölüm.

Değişken, belirli özniteliğin constyöntemlerin içinden değiştirilebilir olarak işaretlenmesidir . Tek amacı bu. Kullanmadan önce dikkatlice düşünün, çünkü tasarımı kullanmak yerine tasarımı değiştirirseniz kodunuz muhtemelen daha temiz ve daha okunabilir olacaktır mutable.

http://www.highprogrammer.com/alan/rants/mutable.html

Eğer yukarıdaki delilik değişebilir ne için değilse, ne için? İşte ince durum: mutable, bir nesnenin mantıksal olarak sabit olduğu, ancak pratikte değişmesi gereken durum içindir. Bu vakalar çok az ve çok uzak, ama var.

Yazarın verdiği örnekler, önbellekleme ve geçici hata ayıklama değişkenlerini içerir.

Önbellek gibi dahili durumunuzu gizlediğiniz durumlarda kullanışlıdır. Örneğin:

Sınıf HashTable
{
...
halka açık:
    dize arama (dize anahtarı) const
    {
        eğer (anahtar == lastKey)
            lastValue değerini döndür;

        string value = lookupInternal (anahtar);

        lastKey = anahtar;
        lastValue = değer;

        geri dönüş değeri;
    }

özel:
    değişken dize lastKey, lastValue;
};

Ve sonra bir const HashTablenesnenin hala lookup()dahili önbelleğini değiştiren yöntemini kullanmasını sağlayabilirsiniz .

mutable biri, aksi takdirde sabit bir işlevde veri değiştirmek için izin vermek çıkarım var.

Amaç, nesnenin iç durumuna "hiçbir şey yapmayan" bir işleve sahip olmanız ve bu nedenle işlevi işaretlemenizdir const, ancak bazı nesne durumlarını, doğru durumunu etkilemeyecek şekilde değiştirmeniz gerekebilir. işlevsellik.

Anahtar kelime derleyiciye bir ipucu görevi görebilir - teorik bir derleyici, salt okunur olarak işaretlenmiş sabit bir nesneyi (global gibi) yerleştirebilir. Bunun mutableyapılmaması gereken ipuçlarının varlığı .

Değişken verileri bildirmek ve kullanmak için geçerli bazı nedenler:

• İplik güvenliği. A beyanı mutable boost::mutextamamen makul.
• İstatistik. Bağımsız değişkenlerinin bir kısmı veya tamamı göz önüne alındığında, bir işleve çağrı sayısını sayma.
• Memoization. Bazı pahalı cevapları hesaplayın ve daha sonra yeniden hesaplamak yerine ileride başvurmak üzere saklayın.

Evet, öyle yapar. Bir sınıfın durumunu mantıksal olarak değiştirmeyen yöntemlerle değiştirilen üyeler için kullanıyorum - örneğin, önbellek uygulayarak aramaları hızlandırmak için:

class CIniWrapper
{
public:
   CIniWrapper(LPCTSTR szIniFile);

   // non-const: logically modifies the state of the object
   void SetValue(LPCTSTR szName, LPCTSTR szValue);

   // const: does not logically change the object
   LPCTSTR GetValue(LPCTSTR szName, LPCTSTR szDefaultValue) const;

   // ...

private:
   // cache, avoids going to disk when a named value is retrieved multiple times
   // does not logically change the public interface, so declared mutable
   // so that it can be used by the const GetValue() method
   mutable std::map<string, string> m_mapNameToValue;
};

Şimdi, bunu dikkatli kullanmalısınız - bir arayan sadece constyöntemler kullanıyorsa iş parçacığı güvenli olduklarını varsayabileceği için eşzamanlılık sorunları büyük bir endişe kaynağıdır . Ve elbette, mutableverilerin değiştirilmesi, nesnenin davranışını önemli bir şekilde değiştirmemelidir, örneğin diske yazılan değişikliklerin uygulama tarafından hemen görünmesi bekleniyorsa, verdiğim örnekle ihlal edilebilecek bir şey .

Mutable, sınıf içinde yalnızca bir sınıf veya mutex veya kilit gibi şeyleri bildirmek için kullanılan bir değişkeniniz olduğunda kullanılır. Bu değişken, sınıfın davranışını değiştirmez, ancak sınıfın kendisinin iş parçacığı güvenliğini uygulamak için gereklidir. "Değişken" olmadan, bu nedenle "cons" fonksiyonlarına sahip olamazsınız çünkü bu değişkenin dış dünyadaki tüm fonksiyonlarda değiştirilmesi gerekecektir. Bu nedenle, bir üye değişkeni bir const fonksiyonu tarafından bile yazılabilir kılmak için mutable eklenmiştir.

Belirtilen değişken hem derleyiciye hem de okuyucuya bir üye değişkenin bir sabit üye işlevi içinde değiştirilebileceğinin güvenli olduğunu ve beklendiğini bildirir.

mutable esas olarak sınıfın bir uygulama detayında kullanılır. Sınıfın kullanıcısı bunu bilmek zorunda değildir, bu nedenle yöntem "cons" olabilir gerektiğini düşünüyor. Muteksin değişebilir olması örneği iyi bir kanonik örnektir.

Bunu kullanmanız bir hack değildir, ancak C ++ 'da birçok şey gibi mutable , geri dönüp const olmayan bir şey olarak işaretlenmemesi gereken bir şeyi işaretlemek istemeyen tembel bir programcı için hacklenebilir.

Kullanıcıya MANTIKSIZ vatansız olan (ve bu nedenle genel sınıf API'larında "const" alıcıları olmalıdır) ancak temel UYGULAMADA (.cpp kodunuzda kod) durumsuz OLMAYAN şeyler için "mutable" kullanın.

En sık kullandığım durumlar, devletsiz "sade eski veri" üyelerinin tembel başlatılmasıdır. Yani, bu tür üyelerin inşa etmek (işlemek) veya taşımak (bellek) için pahalı olduğu ve nesnenin birçok kullanıcısının asla istemeyeceği dar durumlarda idealdir. Bu durumda, performans için arka uçta tembel inşaat yapmak istersiniz, çünkü inşa edilen nesnelerin% 90'ının onları asla inşa etmesi gerekmeyecektir, ancak yine de kamu tüketimi için doğru vatansız API'yi sunmanız gerekir.

Mutable const, bitsel sabitin anlamını sınıf için mantıksal sabit olarak değiştirir.

Bu, değiştirilebilir üyelere sahip sınıfların artık bitsel olarak sabit oldukları ve yürütülebilir dosyanın salt okunur bölümlerinde görünmeyecekleri anlamına gelir.

Ayrıca, constüye işlevlerinin değiştirilebilir üyeleri kullanmadan değiştirmesine izin vererek tür denetimini değiştirir const_cast.

class Logical {
    mutable int var;

public:
    Logical(): var(0) {}
    void set(int x) const { var = x; }
};

class Bitwise {
    int var;

public:
    Bitwise(): var(0) {}
    void set(int x) const {
        const_cast<Bitwise*>(this)->var = x;
    }
};

const Logical logical; // Not put in read-only.
const Bitwise bitwise; // Likely put in read-only.

int main(void)
{
    logical.set(5); // Well defined.
    bitwise.set(5); // Undefined.
}

Daha fazla ayrıntı için diğer cevaplara bakın, ancak bunun sadece tür güvenliği için olmadığını ve derlenmiş sonucu etkilediğini vurgulamak istedim.

Bazı durumlarda (kötü tasarlanmış yineleyiciler gibi), sınıfın bir sayıyı veya başka bir tesadüfi değeri tutması gerekir, bu da sınıfın ana "durumunu" gerçekten etkilemez. Bu çoğunlukla mutable kullanıldığını gördüğüm yerdir. Değişken olmadan, tasarımınızın tüm yapısını feda etmek zorunda kalacaksınız.

Bana da çoğu zaman bir saldırı gibi geliyor. Çok az durumda kullanışlıdır.

Klasik örnek (diğer cevaplarda belirtildiği gibi) ve mutableşimdiye kadar kullanılan anahtar kelimeyi gördüğüm tek durum Get, önbelleğin sınıfın bir veri üyesi olarak değil, sınıfın bir veri üyesi olarak uygulandığı karmaşık bir yöntemin sonucunu önbelleğe almak içindir. yöntemdeki statik değişken (çeşitli işlevler veya düz temizlik arasında paylaşım nedeniyle).

Genel olarak, mutableanahtar kelimeyi kullanmanın alternatifleri genellikle yöntemde veya const_castnumarada statik bir değişkendir .

Başka bir ayrıntılı açıklama burada .

Değişken bir const sanal işlevini geçersiz kıldığınızda ve bu işlevdeki alt sınıf üyesi değişkeninizi değiştirmek istediğinizde kullanışlı olabilir. Çoğu durumda, temel sınıfın arabirimini değiştirmek istemezsiniz, bu nedenle kendi değişken değişkeninizi kullanmanız gerekir.

Mutable anahtar sözcüğü, sınıf testi amacıyla taslaklar oluştururken çok kullanışlıdır. Bir const işlevini saplayabilir ve sayaçları veya saplamanıza eklediğiniz herhangi bir test işlevselliğini yine de artırabilir (değiştirilebilir). Bu, stubbed sınıfının arayüzünü olduğu gibi tutar.

Değişken kullandığımız en iyi örneklerden biri derin kopyadır. kopya yapıcısında const &objargüman olarak göndeririz . Böylece oluşturulan yeni nesne sabit tipte olacaktır. Değiştirmek istiyorsak (çoğunlukla değişmeyiz, nadiren değişebiliriz) bu yeni oluşturulan const nesnesindeki üyeleri olarak ilan etmeliyiz mutable.

mutabledepolama sınıfı yalnızca bir sınıfın statik olmayan sabit veri üyesi üzerinde kullanılabilir. Bir sınıfın değişken veri üyesi, const olarak bildirilen bir nesnenin parçası olsa bile değiştirilebilir.

class Test
{
public:
    Test(): x(1), y(1) {};
    mutable int x;
    int y;
};

int main()
{
    const Test object;
    object.x = 123;
    //object.y = 123;
    /* 
    * The above line if uncommented, will create compilation error.
    */   

    cout<< "X:"<< object.x << ", Y:" << object.y;
    return 0;
}

Output:-
X:123, Y:1

Yukarıdaki örnekte, xconst olarak bildirilen bir nesnenin parçası olmasına rağmen üye değişkenin değerini değiştirebiliriz . Bunun nedeni değişkenin değişken xolarak bildirilmesidir. Ancak üye değişkenin değerini değiştirmeye çalışırsanız y, derleyici hata verir.

'Mutable' anahtar kelimesi aslında ayrılmış bir anahtar kelimedir. Genellikle sabit değişkenin değerini değiştirmek için kullanılır.

//Prototype 
class tag_name{
                :
                :
                mutable var_name;
                :
                :
               };