गैर-तुच्छ सी ++ कब्ज से संबंधित दोहराव से बचने के लिए, क्या ऐसे मामले हैं जहां कॉन्स्टोकैस्ट काम करेगा, लेकिन एक गैर-कॉन्स्टेबल फ़ंक्शन गैर-कॉन्स्टेंट को वापस करेगा?
स्कॉट मेयर्स के प्रभावी C ++ आइटम 3 में, वह सुझाव देते हैं कि एक स्थिर कलाकार के साथ संयुक्त एक const_cast डुप्लिकेट कोड से बचने के लिए एक प्रभावी और सुरक्षित तरीका हो सकता है, उदा।
const void* Bar::bar(int i) const
{
...
return variableResultingFromNonTrivialDotDotDotCode;
}
void* Bar::bar(int i)
{
return const_cast<void*>(static_cast<const Bar*>(this)->bar(i));
}
मेयर बताते हैं कि कॉन्स्ट फंक्शन को नॉन-कॉस्ट फंक्शन कहना खतरनाक है।
नीचे दिया गया कोड एक काउंटर-उदाहरण दिखा रहा है:
- मेयर्स के सुझाव के विपरीत, कभी-कभी स्थिर कलाकारों के साथ संयुक्त const_cast खतरनाक होता है
- कभी-कभी कांस्ट फ़ंक्शन को नॉन-कॉस्ट कहना कम खतरनाक होता है
- कभी-कभी एक const_cast का उपयोग करने के दोनों तरीके संभावित उपयोगी संकलक त्रुटियों को छिपाते हैं
- एक const_cast से परहेज करना और एक अतिरिक्त कॉन्स्टेबल प्राइवेट मेंबर को नॉन-कॉस्ट वापस करना एक और विकल्प है
क्या कोड डुप्लीकेशन से बचने की कास्ट_कास्ट रणनीतियों में से कोई भी अच्छा अभ्यास माना जाता है? क्या आप इसके बजाय निजी पद्धति की रणनीति पसंद करेंगे? क्या ऐसे मामले हैं जहां const_cast काम करेगा लेकिन एक निजी तरीका नहीं होगा? क्या अन्य विकल्प (नकल के अलावा) हैं?
Const_cast रणनीतियों के साथ मेरी चिंता यह है कि भले ही कोड सही होने पर लिखा जाए, बाद में रखरखाव के दौरान कोड गलत हो सकता है और const_cast एक उपयोगी संकलक त्रुटि छिपाएगा। ऐसा लगता है कि एक आम निजी समारोह आम तौर पर सुरक्षित है।
class Foo
{
public:
Foo(const LongLived& constLongLived, LongLived& mutableLongLived)
: mConstLongLived(constLongLived), mMutableLongLived(mutableLongLived)
{}
// case A: we shouldn't ever be allowed to return a non-const reference to something we only have a const reference to
// const_cast prevents a useful compiler error
const LongLived& GetA1() const { return mConstLongLived; }
LongLived& GetA1()
{
return const_cast<LongLived&>( static_cast<const Foo*>(this)->GetA1() );
}
/* gives useful compiler error
LongLived& GetA2()
{
return mConstLongLived; // error: invalid initialization of reference of type 'LongLived&' from expression of type 'const LongLived'
}
const LongLived& GetA2() const { return const_cast<Foo*>(this)->GetA2(); }
*/
// case B: imagine we are using the convention that const means thread-safe, and we would prefer to re-calculate than lock the cache, then GetB0 might be correct:
int GetB0(int i) { return mCache.Nth(i); }
int GetB0(int i) const { return Fibonachi().Nth(i); }
/* gives useful compiler error
int GetB1(int i) const { return mCache.Nth(i); } // error: passing 'const Fibonachi' as 'this' argument of 'int Fibonachi::Nth(int)' discards qualifiers
int GetB1(int i)
{
return static_cast<const Foo*>(this)->GetB1(i);
}*/
// const_cast prevents a useful compiler error
int GetB2(int i) { return mCache.Nth(i); }
int GetB2(int i) const { return const_cast<Foo*>(this)->GetB2(i); }
// case C: calling a private const member that returns non-const seems like generally the way to go
LongLived& GetC1() { return GetC1Private(); }
const LongLived& GetC1() const { return GetC1Private(); }
private:
LongLived& GetC1Private() const { /* pretend a bunch of lines of code instead of just returning a single variable*/ return mMutableLongLived; }
const LongLived& mConstLongLived;
LongLived& mMutableLongLived;
Fibonachi mCache;
};
class Fibonachi
{
public:
Fibonachi()
{
mCache.push_back(0);
mCache.push_back(1);
}
int Nth(int n)
{
for (int i=mCache.size(); i <= n; ++i)
{
mCache.push_back(mCache[i-1] + mCache[i-2]);
}
return mCache[n];
}
int Nth(int n) const
{
return n < mCache.size() ? mCache[n] : -1;
}
private:
std::vector<int> mCache;
};
class LongLived {};
एक गेट्टर जो सिर्फ एक सदस्य को लौटाता है वह एक से कम है जो खुद को अन्य संस्करण कहता है। चाल अधिक जटिल कार्यों के लिए अभिप्रेत है जहां कटौती का लाभ कास्टिंग के जोखिमों को दूर करता है।
—
सेबेस्टियन रेडल
@ सेबैस्टियनरेडल मैं मानता हूं कि सिर्फ रिटर्निंग मेंबर होने पर नकल बेहतर होगी। कृपया कल्पना करें कि यह अधिक जटिल है, उदाहरण के लिए mConstLongLived को वापस करने के बजाय, हम mConstLongLived पर एक फ़ंक्शन को कॉल कर सकते हैं जो एक कॉन्स्ट रेफरेंस देता है जो तब एक अन्य फ़ंक्शन को कॉल करने के लिए उपयोग किया जाता है जो एक कॉन्स्टेंट रेफ़रेंस लौटाता है जो हमारे पास है और केवल इसके लिए एक्सेस है का एक कास्ट संस्करण। मुझे उम्मीद है कि यह बात स्पष्ट है कि const_cast कुछ से कब्ज को दूर कर सकता है जिसे हम अन्यथा नॉन-कास्ट एक्सेस नहीं करेंगे।
—
JDiMatteo
यह सब साधारण उदाहरणों के साथ हास्यास्पद लगता है, लेकिन कास्ट से संबंधित दोहराव वास्तविक कोड में आता है, कॉस्ट कंपाइलर त्रुटियां व्यवहार में उपयोगी होती हैं (अक्सर बेवकूफ गलतियों को पकड़ने के लिए), और मुझे आश्चर्य है कि प्रस्तावित "प्रभावी सी ++" समाधान एक अजीब है और प्रतीत होता है कि जाति की त्रुटि-प्रवण जोड़ी। एक गैर-कॉन्स्टेंट लौटने वाला एक निजी कांस्ट सदस्य एक डबल कास्ट के लिए स्पष्ट रूप से बेहतर लगता है, और मैं जानना चाहता हूं कि क्या कुछ ऐसा है जो मुझे याद आ रहा है।
—
JDiMatteo