מכל מיני סיבות, יש לי מצב כזה בערך: מחלקת בסיס B שממנה יורשות מחלקות D1, D2, D3, וכו'. ליתר דיוק, יורשת תבנית מחלקה, אבל זה לא משנה מהותית את הבעיה. משהו כזה:

קוד:

class B {
	B() = 0;
	~B();
	std::string getTypeName();
}

template <typname T>
class D : public B {
	D();
	~D();
 	std::string getTypeName();
	void setVar (const T& newVal);
	T getVar();
}

המטרה של כל העסק היא לשמור רשימה של פריטי מידע מסוגים שונים. משהו כזה:

קוד:

std::vector<B*> myVec;

כדי להשתמש ב-getVar או ב-setVar צריך לעשות dynamic_cast לטיפוס המתאים (שאותו מגלים בעזרת getTypeName), ואז לבצע getVar/setVar.

עד פה הכל טוב, חוץ מזה שיש לי המון מצביעים "ידניים". הפיתרון המובן מאליו הוא להשתמש ב-auto_ptr (או ב-shared_ptr, אם כבר) ושלום על ישראל. מובן מאליו שהפיתרון המובן מאליו לא פועל, כי auto_ptr< D<int> >‎ או auto_ptr< D<std::string> >‎ לא יורשים מ-auto_ptr<B>‎ (הם unrelated types). כלומר, אי אפשר לעשות dynamic_cast מה-auto_ptr שיש לי ל-auto_ptr לטיפוס האמיתי.

כמובן שאם היה מדובר בסתם פונקציות וירטואליות, לא הייתה שום בעיה (אז בעצם אפילו לא היה צורך ב-dynamic_cast, והפונקציה הייתה מוצהרה כבר בתוך B), אלא שכאן הטיפוסים שונים בכל מחלקת-בת.

אני מניח שאני יכול לגנוב מה-auto_ptr את המצביע שאליו הוא מצביע, לעשות לו dynamic_cast, לקרוא לפונקציות, ואז להמשיך עם ה-auto_ptr, אבל ברגע שאני גונב מה-auto_ptr את המצביע, אפילו לשנייה, אני די מפספס את כל הרעיון של השימוש בו. לא?

האמת, שזו בעייה שכבר שמעתי עליה, אבל לא עולה לי כרגע פיתרון לראש. אגב, אם למישהו יש דרך אחרת לשמור רשימה אחת של פרמטרים מסוגים שונים (לא כולל struct של enum של טיפוס ומצביע ל-void או שטויות C כאלה) גם אשמח לשמוע.

יש הצעות?

אבל אני חושב שזה לא ממומש ב- auto_ptr אתה יכול לממש את זה בעצמך.
הרעיון הוא כזה, יש לך מחלקה שעוטפת לך את מצביע, אתה מגדיר למחלקה הזאת אופרטור <- שמחזיר את המצביע העטוף (האופרטור חייב להיות אונרי, כלומר אינו מקבל פרמטרים).
עכשיו הגיוני שתשאל "מה כ"כ מיוחד ברעיון הזה?! זה כמו לקחת את המצביע מתוך ה- auto_ptr"
עקרונית אתה צודק, אבל אתה תוכל לעשות דבר כזה:

קוד PHP:

 class A {
public:
    void func1();
    int func2();
private:
    // Some members...
};

class A_ptr {
public:
    A_ptr();    // Allocates new A object.
    ~A_ptr();  // Deletes the memory allocated.
    A* operatror->();
private:
    A* a;
}

int main () {
    A_ptr pa;
    
    // This calls the function func1 of the object a stored in pa
    pa->func1();
} 


הרעיון כאן הוא שאתה כן משתמש במצביע עצמו אבל לא בצורה ישירה, ואתה עדיין שומר על העטיפה ש-ptr מספק לך.

מקווה שזה עזר לך. (וכדאי לבדוק, יש מצב שזה כן ממומש ב- auto_ptr)

[התמונה הבאה מגיעה מקישור שלא מתחיל ב https ולכן לא הוטמעה בדף כדי לשמור על https תקין: http://www.fresh.co.il/scripts/birthday.php?date=27/04/1986]

אז יש לי אובייקטי A_ptr שמצביעים לאובייקטים מטיפוס A ואובייקטים מטיפוס B_ptr שמצביעים לאובייקטים מטיפוס B ואובייקטים מטיפוס C_ptr שמצביעים לאובייקטים מטיפוס C, אבל אני עדיין לא יכול לעשות dynamic_cast בין A_ptr ו-B_ptr ל-C_ptr כי גם אם A ו-B יורשים מ-C, המחלקות A_ptr ו-B_ptr לא יורשות מ-C_ptr.