สำหรับการหลีกเลี่ยงการทำซ้ำที่ไม่เกี่ยวข้องกับ C ++ const มีกรณีที่ const_cast จะทำงานได้ แต่ฟังก์ชั่น const ส่วนตัวที่ส่งกลับไม่ใช่ const จะไม่?
ในรายการC ++ ของ Scott Meyers ที่มีประสิทธิผล 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 เรียกฟังก์ชันที่ไม่ใช่ const นั้นเป็นอันตราย
รหัสด้านล่างคือตัวอย่างที่แสดงให้เห็น:
- ตรงกันข้ามกับข้อเสนอแนะของเมเยอร์สบางครั้ง const_cast รวมกับตัวบล็อกคงเป็นอันตราย
- บางครั้งฟังก์ชั่น const เรียกว่าไม่ใช่ const เป็นอันตรายน้อยกว่า
- บางครั้งทั้งสองวิธีใช้ const_cast ซ่อนข้อผิดพลาดของคอมไพเลอร์ที่อาจเป็นประโยชน์
- การหลีกเลี่ยง const_cast และการเพิ่มสมาชิกส่วนตัว const เพิ่มเติมที่ส่งคืนค่าที่ไม่ใช่ const เป็นอีกตัวเลือกหนึ่ง
กลยุทธ์ 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 {};