עשיתי מחלקה שיכולה ליצור מערך, להרחיב אותו וכו'. אני רוצה שזה יהיה אפשרי לכל סוגי המערכים שיש (int, char, וכו') ואני חושב שעושים את זה עם template.
מצאתי דוגמא אבל לא הבנתי בה כלום באיך המחלקה בנויה:

קוד:

class CTypeSize
{
public:
	template<class T>
	CTypeSize(const T &t1) :
	 m_nSize(sizeof(t1))
	{
	}
	~CTypeSize(void){ };
	int getSize(void) const{ return m_nSize; }
private:
	const int m_nSize;
};

מישהו יכול להסביר לי בבקשה?
אם יש דרך אחרת לעשות את מה שאני צריך, בבקשה תגידו

בכל מקרה אתה צודק, צריך להשתמש ב template, מה השאלה שלך בדיוק?

(המחלקה שהבאת מראה את הגודל של סוג המשתנה... זה בעצם סתם sizeof בצורה של מחלקה...)

חתימתכם הוסרה כיוון שלא עמדה בחוקי האתר. לפרטים נוספים לחצו כאן. תוכלו לקבל עזרה להתאמת החתימה לחוקים בפורום חתימות וצלמיות.

לא הבנתי את החלק הזה:

קוד:

 CTypeSize(const T &t1) :
	 m_nSize(sizeof(t1)) 

באף מדריך שלמדתי ממנו לא הסבירו על זה..
מה שהבנתי בערך זה שמכניסים ל m_nSize את הערך sizeof(t1) אבל למה לא לכתוב בתוך הסוגריים {} שבאים אחרי CTypeSize
m_nSize = sizeof(t1) ?

כדי שההסבר יצליח, אתה צריך לדעת באופן כללי איך עובד OO ב-CPP, וליתר דיוק: איך
פועלים בנאים, ואיך פועל הורשה.
כאשר יש לנו מחלקת בסיס b וממנה יורשות מחלקות d1,d2,d3,... ואנחנו רוצים שהבנאי
של מחלקה d2, לדוגמה, יבצע קוד מסויים בנוסף לביצוע הקוד של הבנאי של מחלקת
הבסיס b, אנחנו נכתוב כך בערך:

קוד PHP:

 class b
  {
  private:
  ...
  protected:
  ...
  public:
      b(int i, float f, char c)
      {
      ...
      }
  ...
  }
  
  
  class d1 : public b
  {
  private:
  ...
  protected:
  ...
  public:
      d1(int i, float f, char c, double d, long l) : b(i, f, c)
      {
      ...
      }
  ...
  } 


שים לב לחלק הזה:

d1(int i, float f, char c, double d, long l) : b(i, f, c)
{
/* b(i, f, c); */
...
}

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

קוד PHP:

 m_nSize = sizeof(t1); 


נ.ב.
אולי יש לי טעויות סמנטיות טפשיות, אבל לא נגעתי ב-CPP בפרט או בתכנות בכלל כבר
המוווון זמן, אז תסלחו לי

אתה עושה איתחול INLINE לאובייקטים מוכלים או מורשים, כלומר הם מאותחלים עוד לפני שמופעל הבנאי של המחלקה (כדי שהבנאי יכיר אותם וידע "מי בנה אותו" )

בדיוק עכשיו אני פותר תרגיל עם התחכמות בעניין הזה (איך גורמים להדפסה של משהו על המסך, עוד לפני הכניסה ל-main)

תסביר לאט לאט

בעיקרון כל בנאי של כל מחלקה יכול לאתחל את הנתונים כבר ברגע שהוא מוגדר, ועוד לפני שקוראים לו. כאן מגיע העניין של הנקודותיים, שמאפשר לנו לאתחל את הנתונים עוד לפני שנכנסנו לבנאי. קוראים לזה INIT LINE (ולא כמו שרשמתי מקודם).

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

קוד:

class Line {
		Point p1,p2;
	public:
		Line (int x1, int y1, int x2, int y2) : p1(x1,y1), p2(x2,y2) {}
}

ב. אם יש לנו הורשה, המצב דומה - קוראים לבנאי של האב לפני הבנאי של הבן.
זו הדרך היחידה לאתחל אותם const ג. אם יש לנו משתנים שהם
,

ציטוט:

במקור נכתב על ידי Jarvis . זו הדרך היחידה לאתחל אותם const ג. אם יש לנו משתנים שהם

תודה, זאת היתה הבעיה שלי

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

אם עדיין לא הסתדרת עם המחלקה שלך, תדביק את הקוד פה, ואז יהיה הרבה יותר קל לעזור.
בהצלחה.

טוב זאת המחלק שיצרתי לטיפול במערכים:

קוד:

class Array
{
	 private:
	 int *nArr;
	 int aSize;
 
	 public:
	 Array() { aSize = 0; }
	 ~Array() { };
 
	 void AddElement(int nVal)
	 {
		 int *tArr = new int[aSize+1];
		 for(int i=0; i<aSize; i++)
		 tArr[i] = nArr[i];
		 tArr[aSize] = nVal;
		 delete[] nArr;
		 nArr = tArr;
		 aSize++;
	 }
}; 

וזה עובד והכל בסדר.
ניסיתי לשנות אותה כדי שאני יוכל ליצור מערכים לכל סוגי המידע:

קוד:

class Array
{
	 private:
	 Type *nArr;
	 int aSize;
 
	 public:
	 template<class Type>
	 Array() { aSize = 0; }
	 ~Array() { };
 
	 void AddElement(Type &nVal)
	 {
		 Type *tArr = new Type[aSize+1];
		 for(int i=0; i<aSize; i++)
		 tArr[i] = nArr[i];
		 tArr[aSize] = nVal;
		 delete[] nArr;
		 nArr = tArr;
		 aSize++;
	 }
};

אבל זה כבר לא עובד.
זה בטח מלא בהרבה טעויות אז מישהו יכול לעזור לי בבקשה?

סוף סוף הצלחתי לתקן את זה..
תודה לכל העוזרים.