יש לי תוכנית מאוד גדולה עם הרבה מחלקות (class).
ואני צריך להדפיס הערות שגיאה מכמעט כל מקום בקוד.
כמובן שאני יכול לכתוב פונציית print לכל מחלקה אבל אני רוצה שכולם ידפיסו לאותו הקובץ.
האם במקרה זה אני יכול להשתמש במשתנה גלובלי שמייצג את הקובץ logfile ?
או שאולי יש דרך נקייה יותר ששומרת על כתיבה נכונה של object oriented programming ?
אשמח אם תוכלו לתת לי הצעות.

הערה:

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

הוא מקבל שגיאה ומכניס אותה לקובץ... עכשיו יש לך אפשרות אחת והיא - לעשות אותו גלובלי(לא יודע עד כמה זה טוב) ואפשרות שנייה היא לעשות שבכל אתחול של אובייקט הוא יקבל מצביע לאובייקט של השגיאה
וכך הוא יוכל לתקשר איתו.

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

BJ_ERROR << "some error";

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

(הקוד ממש לא מושלם... תבין את הרעיון ותממש את זה באופן יותר טוב)

קוד:

 

#include <iostream.h>
class CError
{
	public:
		void operator <<( char *strErr ) { cout << "ERROR: " << strErr << endl; }
} BJ_ERROR ;
class A
{
	public:
		void error() { BJ_ERROR << "class A - bla bla"; }
};
class B
{
	public:
		void error() { BJ_ERROR << "class A - bla bla"; }
};
int main( void )
{
	A obj1;
	B obj2;
	obj1.error();
	obj2.error();
 
	return 0;
}

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

אני אדגים שיטה לדוגמה לביצוע

נגדיר מחלקה בסיסית שממנה יירשו כל!!!! המחלקות שאני כותב.
כמו כן, תהיה לי מחלקה לטיפול בחריגות/שגיאות:

קוד:

 class ErrorHandler   {
 	private:
 	    # here come vars and functions to handle error
 	    # and output to file log and so on
 	protected:
 		void set_error(here come error id
      		    	    or any type of way to
 			      identify the error
      		    	     or the object sent it);
 
 }
 
 class BaseObject {
 	protected:
 		ErrorHandler* err;
 		.....
 }
 
 class A : public BaseObject {
 	.....
 	
     # here when you have the try-catch block
  # you use the set_error to write an error to log file
 }
 
 

[ זיו ]
[ fat fish ]

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

המחלקה ErrorHandler כותבת רק לקובץ אחד!!!!
וכולם משתמשים במופע של המחלקה הזו.

התשובה שלך מראה שאתה צריך לעבור קצת על עקרונות תכנות מוככן עצמים (OO).
אני מאוד ממליץ להבין לעומק את העקרונות הללו, מאחר שהרבה המתכנתים
נופלים בפח, ומתייחסים למחלקות ב ++C כמו למבנים ב C ולמעשה מתכנתים ב ++C
תכנות פרוצדוריאלי.

[ זיו ]
[ fat fish ]

Error Handler נוצר פעם אחת.
אבל (ErrorHandler* err) נוצר לכל מופע.
זאת אומרת שיש לך עשרות אלפי פויינטרים ל: ErrorHandler.
חוץ מזה, האתחול של err צריך להעשות ב- constructor שלו.
זה נראה לי קצת מסובך.

האם לא עדיף להשתמש ב- Error Handler גלובלי ללא כל הפויינטרים הללו ?

יש לך מחלקה שכותבת לקובץ:
log.txt
אזי כל מופע שלה כותב לקובץ הזה!!!

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

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

[ זיו ]
[ fat fish ]

עם כל הכבוד לזה שאתה עוזר לי ואני מאוד מעריך את זה,
אני לא מבין למה אתה חוזר על זה שאני לא מבין תכנות מונחה עצמים.
יכול להיות שאתה לא מבין את השאלה.
מי אמר שאתה כותב לשם של קובץ שידוע מראש ?
השם של הקובץ ניתן תוך כדי כתיבת התוכנית.
אני לא מבין איך כל האובייקטים יקבלו בצורה אוטומטית את ה- logfile ?

למה כל המופעים צריכים "לקבל" את הערך logfile...?

בוא נראה מבנה עקרוני של המחלקה ErrorHandler
כתבתי כמה שורות על מנת שנוכל לנתח אותן:

קוד:

 class ErrorHandler
{
public:
	ErrorHandler();
	ErrorHandler(CString);
	virtual ~CErrorHandler();
protected:
	CString sErrFile;
	void rise_err(UINT,UINT);
};
ErrorHandler::CErrorHandler() : sErrFile("log.txt")
{
}
ErrorHandler::CErrorHandler(CString errfile) : sErrFile(errfile)
{
}
void ErrorHandler::rise_err(UINT nObjid, UINT nErrid)
{
while (file is already open with another session);
add to file nObjid, nErrid, date, time
}

במחלקה יש לנו בנאי ברירת מחדל שמגדיר לנו את המשתנה sErrFile
משתנה זהב מחזיק את הנתיב לקובץ השגיאות שלנו.

במקרה זה נתתי לו ערך בעצמי, אך כמובן שהערך ששולחים אליו, יכול להיות קבוע (const)

יש לנו גם בנאי לא טריוויאלי, אשר דרכו ניתן להגדיר קובץ אחר.

בתכנית שלך, כמו שאני מבין, מספיק הבנאי הראשון.
בתכניות בהן רוצים לדוגמה להפריד בין סוגי השגיאות (שגיאות קלט/פלט) שגיאות
טיפול בקבצים וכו - ניתן להגדיר בכל אובייקט את שם הקובץ.

כמובן שאנו לא צריכים ממש לכתוב את שם הקובץ בכל מחלקה ומחלקה, אלא שוב
ליצור מחלקה בין מחלקת הבסיס שלנו לבין המחלקות המתאימות, לדוגמה:
מחלקה בשם io_base, מחלקה שממנה ירשו כל המחלקות המטפלות ב-io והיא עצמה
תירש מ- BaseObject.
הבנאי של מחלקה זו - הוא זה המגדיר את קובץ הפלט שלנו (לדוגמה io_err.txt)

גם את נושא התזמון של כתיבה לקובץ, ניתן לפשט ולכתוב לחוצץ בזיכרון (שהתזמון
שלו יותר פשוט) ולתת למחלקה הראשית של התכנית לתזמן מתי כל החוצץ יכתב/יזרק
לקובץ (dumping).

אני מקווה שההסבר הזה היה ברור יותר,
(:

[ זיו ]
[ fat fish ]

הבנתי את הפתרון שהצעת. הבעייה היא שהפתרון מנסה לפתור משהו מסובך יותר.
נניח ש- ErrorHandler נוצר בפונקציה main.
הוא צריך להיות האובייקט הראשון שנוצר מאחר וצריך להעביר פויינטר אליו מכל אובייקט שנוצר.
זה אומר שב- constructor של כל אובייקט צריך להעביר פויינטר ל- ErrorHandler בשביל לאתחל את BaseObject.

אבל אתה לא מפנים את עקרון ה-OO.
פונקצית main בתכנות OO בשפת C++ לא צריכה לעשות כלום למעט
הקמת אובייקט האפליקציה הראשי שלך!

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

[ זיו ]
[ fat fish ]

יכול להיות שאני באמת לא מבין.
אשמח אם תוכל להסביר לי.

להלן שאלותיי:

איך נראה הבנאי של class A ? כלומר איזה פרמטרים הוא צריך ?
יותר נכון, איך מאתחלים את class BaseObject ?
האם שני אובייקטים(לא מחלקות) שונים יכולים לרשת מאותו אובייקט(לא מחלקה) ? אם כן, אני צריך דוגמא .

תודה לך.

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

האר את עיני בבקשה למנגנונים "פשוטים יותר ופונקציונאליים יותר וכו.."
כל עוד הם עומדים בקנה אחד עם עקרונות תכנון OO !

אתה יודע שאני תמיד שמח ללמוד עוד (ולא, אני לא יורד עליך - אלא מדבר ברצינות)

[ זיו ]
[ fat fish ]

לא אמרתי פונקציונאליים יותר, אלא במידה מספקת.

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

לדיווח על שגיאות, מספיק להשתמש ב-cmyerr, שיכתוב לקובץ לוג, וע"מ
לאתר אותן ניתן להשתמש בשיטת C הישנה והטובה - בדיקת הערכים
המוחזרים מהפונקציות...
כל המטרה של מנגנון החריגים בעצם היא לאפשר לך לא לבדוק את
הערכים המוחזרים. במקרה שתתבצע שגיאה בחלק שהוא try, התכנית
תקפוץ לטיפול בשגיאה.
ואם כבר אנחנו פה - איך מזהים שגיאות כמו חלוקה באפס באמצעות
חריגים?

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

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

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

התכוונתי יותר למה הבעייה עם משתנה גלובלי ?
ברור שאני לא אממש את הטיפול בשגיאות ככה בדיוק.

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

אמנם הציגו פה מס' דרכים ל-logging/tracing, צריך להזכיר שיש הרבה מעבר למה שהוצג.
התהליך הנ"ל יכול להאיט את האפליקציה בצורה משמעותית, הרבה מעבר למה שרוב האנשים חושבים.
הסבר/הרחבה תמצא בספר Practice of Programming.

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

Boost, Log4cpp, log4cxx
(שלושתן מצויינות וחינמיות)

C pogrammers never die. They are just cast into void.