anlamsal - listelerinde> operatör (ve genel C++) ile

Question

Benim şu anki atama adım adım elde listesini yazıyor. Liste, yineleyici sınıfı oluşturmak kadar çok sorun oluşturmuyor.

Birkaç kaynaktan, yineleyici sınıfımda tanımlamak için iki operatörün olduğunu gördüm: operator* ve operator->.

Şimdiye kadar harika! Benim yineleyici yapısını düşünürsek ListElem

// Nested struct of List 
struct ListElem 
{ 
    T data; 

    ListElem *next; 
    ListElem *prev; 
}; 

olmak öylesine

// Nested class of List 
class _Iter 
{ 
private: 
    ListElem *pCurr; 
    const List *pList; 

public: 
    _Iter(ListElem *pCurr, const List *list) 
     : pCurr_(pCurr), pList(list) 
    {} 

    T& operator*() { return pCurr_->data; } 
    T* operator->() { return &**this; } 
}; 

olduğunu ben & (* pCurr _-> verilerine yol açacak bu çifte dereferencing olarak (kitlesel yanlış bir şey yapıyorum görebilirsiniz (bu, kabul edilemez)

Asıl problemim, aslında bu durumda ne yapması gerektiğini anlamak değil, kullanıcı ListElem sınıfına erişim izni vermeli mi? sadece

yaz

ListElem *operator->() { return pCurr_; } 

yerine bir işaretçi döndürmek?

operator*() // Return data pointed to by iterator; pCurr_->data; 
operator->() // Grant access to data-holding structure; pCurr; 

bu doğru mu, yoksa ne almıyorum: listemde (ve umarım STL listeleri) kullanılan bu iki operatörlerin Benim anlayış bu? (Ve ->, uygun bir ada sahip mi?)

Answer 1

Ne yaparsanız yapın, (*something).somethingElsesomething->somethingElse denk olmalıdır. İkincisi, eski için kısa bir sözdizimi. *this sadece tip _Iter* değil _Iter, hiçbir operator*() çağrı yapılır sahiptir this dereferences çünkü nedenle,

T& operator*() { return pCurr_->data; } 
T* operator->() { return &**this; } 

gayet iyi.Sonra *this dereferans, böylece pCurr->data olsun, sonra adresini alırsınız, böylece & pCurr-> veri alırsınız. Ama sadece yazmak için çok daha net olacaktır: operator*() döner T&, operator->() T* dönmesi gerekir, o ne için tasarlanmıştır çünkü Şimdi

T& operator*() { return pCurr_->data; } 
T* operator->() { return &pCurr->data; } 

, bu

ListElem *operator->() { return pCurr_; } 

yanlıştır. ListIt yerine kendi verilerinin yerine veriyi vermek istiyorsanız (ki bu tasarıma göre anlam kazanabilir ya da olmayabilir, fakat sizin durumunuza benzemiyorsa), bunu elde etmek için operator*()'u da yeniden tanımlamanız gerekir:

ListElem& operator*() { return *pCurr_; } 
ListElem *operator->() { return pCurr_; } 

Bu, bir dil gereksinimi olmadığını unutmayın, aynı zamanda, sınıfınızı kafa karıştırıcı arabirimden kaçınmak için nasıl tasarladığınızdır.

Answer 2

operator->, yineleyici tarafından gösterilen nesneye bir işaretçi verir, bu durumda (görünüşte) pCurr_->data.

T *operator->() { return &(pCurr_->data); } 

bir değer veya referans olarak operator*() tarafından döndürülen nesnenin adresine döndürmelidir.

T &operator*() { return pCurr_->data; } 
// or 
T &operator*() { return *operator->(); } 

operator->() ve operator* değeri yerine referans ile bir nesne, geri dönmek için gereklidir (işaretçiler için olan davranış) ile adım adım elde -> uygulamaktır. Eğer gerekli işlevselliği elde etmek Yineleyici içinde List bir işaretçi saklamak gerekmez

Not.

Answer 3

Kişisel Birinci kural

(*iter).hello(); 
iter->hello(); 

de aynı şeyi yapması gerektiğini olmalıdır. Bu kullanıcının beklediği şey. Geri dönen ListElem kullanıcıya hiçbir şey vermez. Kullanıcı, ListElem uygulamasının ayrıntılarını bile bilmemelidir.