שלום!
אני, כפי שאתם יכולים לראות בעמוד הראשי, החלטתי להתחיל ללמוד C#\Java
בסוף העדפתי את #C והתחלתי ללמוד אותה.
אני מתחיל בעזרת סרטונים באינטרט מהאתר LearnVisualStudio.Net
שהומלץ לי ע"י בן דוד שלי שיודע כבר מס' שפות Net. ולומד היום מדעי המחשב בטכניון.

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

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

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

התחלתי את השנה עם אפס ידע. לכן כתבתי את ההודעה הזאת בכדי ש"תרגיעו" אותי (אני מתייחס להודעה על פסקל), כיום אני יודע לתכנת במס' שפות היום ביניהן: C,CPP,TP,HTML,ASP ובעתיד ASP.NET וCS.

אני מעוניין להגיב להודעה הזאת, לאחר שנתיים של התנסות בפסקל ובשפות תכנות:

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

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

ציטוט:

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

(ציטוט מההודעה על פסקל)


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

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

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

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

pyr0

שמחה לשמוע שעדיין יש מורים טובים בתיכון, כאלה שיכולים לתת השראה לתלמידים. יש לך מזל !!

כדאי לציין, אגב, שאם אתה מכיר את העקרונות שעומדים מאחורי מדעי המחשב, כל שפת תכנות היא בעצם אותו דבר, בשינויי SYNTAX כאלה ואחרים. רקורסיה היא רקורסיה, לא משנה אם היא בפסקל, C, או אפילו HASKELL.
בחירת שפת תכנות ,כמו שאני רואה את זה, היא כמו בחירת כלי עבודה של נגר - לוקחים את מה שהכי מתאים למטלה הנוכחית. ל-NET. יש ספריית CLASS-ים גדולה ומפורטת שעובדת נהדר - לדברים מסויימים. כנ'ל JAVA. אבל לדוגמא, למשימות שדורשות עיבוד טקסט, PERL תנצח כמעט תמיד כי היא חוסכת לי זמן פיתוח (על חשבון זמן הריצה של המחשב). וכשרוצים לכתוב משהו שנראה כמו משוואה מתמטית (כן, יש דברים כאלה...) אז אחת מהשפות הפונקציונאליות בד'כ מתאימה בול.
כמובן, כל הנ'ל בערבון מוגבל... :-)

JAM

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

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

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

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

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

קל? לא בשבילי.

סאשה הסוס, סוכן אוסינט.‏

לא הבנתי את רוב מה שכתבת, מה הקשר לזה ולאשכול?

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

סאשה הסוס, סוכן אוסינט.‏

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

"ללמוד לנסח משפטים".

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

סאשה הסוס, סוכן אוסינט.‏

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

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

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


===================

אני גם לא רוצה להגיב להודעות האחרות שלך באשכול הזה, כי זה לא הגיוני שאני אגיד את אותו הדבר בכולם.

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

אני לא מצפה התנהגות כזאת מאדם בגילך (אני מעריך... 25+)

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

יש דרכים להגיד דברים, והדרך שהוא אמר הייתה פוגעת.

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

זה שאתה ממשיך להגיד "אבל אני לא מבין איך זה קשור" זה עניינך.

סאשה הסוס, סוכן אוסינט.‏

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

עכשיו אני מבין מה הייתה הכוונה שלך.
אני חוזר בי על כל ההאשמות.

באיזו סביבה אתה מנסה לעשות Remote Debugging? אני נתקלתי תחת VS2003 ובמיוחד 2005 בתופעות
של כשלים בגלל NTLMים שונים על אותה רשת ובעיות של Workgroup/Domain.
וגם עכשיו.. על חלק מהמחשבים אני מריץ RD ע"י הרצה פיזית של הProcess על המחשב בProduction
ובמחשב הDebugging אני עושה Attach to process... במחשבים אחרים ההרצה דרך הDebugger
תקינה לחלוטין...

סוג של וודוו..

דורון

העלתי את הווינדוס עם:

/debug / debugport=com1 /baudrate=115200

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

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

לדעתי, הבעיה היא בווינדוס עצמו ולא ב-windbg, כי הווינדוס עולה בלי לחכות לחיבור
המרוחק כמו שהוא אמור, אבל זה לא שאני יכול לדבג אותו כדי לגלות איפה הבעיה.

סאשה הסוס, סוכן אוסינט.‏

דורון

אשמח אם תלמד אותי לתכנת ב-HTML, כי למטב ידעתי, אין בעולם אדם שיודע לתכנת ב-HTML.

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

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

בהצלחה

אני לא מסכים שHTML היא לא שפת תכנות, היא שפת תכנות מאוד בסיסית.
בקשר לתלמד php "לטובתך ולטובת האנושות", למה?

אתה לא חייב להסכים, אך זה לא ישנה עובדות.
html, xml ושאר מרעין בישין, הינן "שפות סימון".
אם אתה מתעקש דווקא לדייק, אז שפות נוספות שציינת אינן שפות תכנות. לדוגמה, asp, היא שפת תסריט (script language) ולא שפת תכנות, אך כאן ההבדל קטן יותר ואף הפעולה של כתיבת קוד בשפת תסריט נקראת "לתכנת".

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

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

XML הוא שם כולל למגוון טכנולוגיות, ביניהן: XSL, XPath, XQuery, XLink, XPointer, וגם XML DOM Scripting, וזה כבר תכנות של ממש. מי ש"יודע XML", אמור לדעת חלק גדול מהדברים הללו, וביניהם תכנות של ממש - בין אם ניתוח חיצוני של XML DOM, או שימוש ב-JavaScript מתוף מסמכי XSL (כן, לפעמים זה ממש נוח, וזה תכנות, כי JS היא שפת תכנות).

סאשה הסוס, סוכן אוסינט.‏

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

XML בכל מקרה אינה שפת תכנות, גם אם נמצא מאפיינים רבים זהים.
XML היא גם שמה של שפת XML ולא "שם משפחה כולל", למרות שישנם שפות כגון SXL שהן שפות "משלימות" ושפות כגון xhtml, MathML שהינן שפות נגזרות של שפת XML.
XML הוא בעצם גירסה קטנה יותר של תקן SGML.

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

XML הוא שם כולל למגוון טכנולוגיות, כך לפחות מקובל בתעשיה. מי שיכול לכתוב מסמכי XML מומצאים, אבל לא יודע להשתמש ב-XML Schema, לא יודע לעבוד עם XPath, ולא יודע לעבוד עם XML DOM לא יכול לומר ש"הוא יודע XML".

סאשה הסוס, סוכן אוסינט.‏

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

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

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

למה בדיוק ללמוד PHP במקום ASP?!
ASP RULEZZZ

לא

ממש ממש כן זה שאתה יודע רק PHP זה משהו אחד מנסיון עם שתי השפות אני אומר לך ש ASP הרבה יותר כיפית

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

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

מה כל כך רע ב ASP אז לא הבנתי..?
אין בו כל כך הרבה מגרעות גם הרבה יותר כיף לכתוב בו...

ציטוט:

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

אין לי כוח...

קודם כל, כיף לקרוא את ההודעה שלך, ולו מהסיבה שהגבת להודעה שכתבת לפני שנה ..

שנית - אנסה לגעת בכמה דברים שאמרת:

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

ב. לגבי Pascal. אני לא יודע לגבי אחרים, אבל אני לא חובב Pascal בתור שפת התחלה היום משתי סיבות:
1. הכיוון של העולם הוא c ושפות מבוססות c. למעשה, זה הפך להיות הsyntax של מרבית השפות היום-
ולא בכדי. php, perl, java, c# - הן מבוססות על c. לכן, כשאתה לומד c - אתה מקרב את עצמך הרבה יותר לעולם.
2. המודרניזציה מאוד פתחה את c ובנותיה, אבל pascal איכשהו נשארה מאחור (מבחינת האימוץ של הכלים החדשים בשוק... יסלחו לי אוהבי Delphi, PascalOO וכו'...).... לא אומר שאין פיתוחים בתחום,
אבל.. פתח את גליון הדרושים בעיתון הסופ"ש ו.. תראה כמה השפה מבוקשת.

דורון

בקשר לחלק א':

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

בקשר לחלק ב', פסקל:

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

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

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

ללמוד C? תזכיר לי, זו השפה שבה טיפול בשגיאות נעשה בעזרת return code או setjmp/longjmp? :\

סאשה הסוס, סוכן אוסינט.‏

מממממ... בעזרת errno ?!...

טיפול בשגיאות ב- c אפשרי דרך win32api.. ראה ערך SEH. עדיף על המנגנון ב- c++ שבנוי עליו.

השאלה הייתה כיצד מטפלים בשגיאות ב-C, ולא שום דבר אחר. SEH הוא מנגנון של המימוש
(נהוג לקרוא לו Windows), ולא של השפה. קיימות עוד מערכות הפעלה, לידיעתך. בנוסף, הוא
באמת ממומש רק ב-VC. לא בכל הקומפיילירים קיימים ‎__try, ‎__except ו-‎__finally של VC.
למען האמת, התיעוד עצמו אומר:

Structured exception handling is made available primarily through
compiler support. For example, the Microsoft C/C++ Optimizing
Compiler supports the __try keyword that identifies a guarded body
of code, the __except keyword that identifies an exception handler,
and the __finally keyword that identifies a termination handler.
Although this overview uses examples specific to the Microsoft
C/C++ compiler, other compilers provide this support as well.

יכול להיות שבקומפיילרים אחרים לווינדוס יש מימוש של SEH (ויכול להיות שלא), אבל כמעט
בטוח שהוא לא יהיה זהה לזה של VC, ואז מה החוכמה? נכתוב קוד שתלוי לגמרי בקומפיילר?
ומה יקרה כשנחליף קומפיילר?

את ההמצאה על כך ש-SEH עדיף על C++ exceptions כדאי שתפסיק לספר, כי אפילו MS
לא חושבים כך. זה לא שהם לא חושבים כך בסתר, אבל בגלוי טוענים כמוך. הם ממש אומרים
את ההפך. שוב, מהתיעוד הרשמי:

Visual C++ supports three kinds of exception handling:

• C++ exception handling
  Although structured exception handling works with C and C++ source
  files, it is not specifically designed for C++. For C++ programs, you
  should use C++ exception handling.
• Structured exception handling
  Windows supplies its own exception mechanism, called SEH. It is
  not recommended for C++ or MFC programming. Use SEH only in
  non-MFC C programs.
• MFC exceptions
  Since version 3.0, MFC has used C++ exceptions but still supports
  its older exception handling macros, which are similar to C++
  exceptions in form. The older MFC exception handling macros have
  been supported since version 1.0. Although these macros are not
  recommended for new programming, they are still supported for
  backward compatibility. In programs that already use the macros,
  you can freely use C++ exceptions as well. During preprocessing,
  the macros evaluate to the exception handling keywords defined in
  the Visual C++ implementation of the C++ language as of Visual
  C++ version 2.0. You can leave existing exception macros in place
  while you begin to use C++ exceptions.

Do not mix the error handling mechanisms; for example, do not use C++
exceptions with SEH. For advice about mixing MFC macros and C++
exceptions, see Exceptions: Using MFC Macros and C++ Exceptions.

לא נעים. טיפול בשגיאות ב-C זה ממש לא נעים.

סאשה הסוס, סוכן אוסינט.‏

ואתה מחליף קומפיילרים כל יום? וגם כתוב:

Although this overview uses examples specific to the Microsoft
C/C++ compiler, other compilers provide this support as well.

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

אפשר להשתמש ב-SEH רק על ווינדוס, בכל שפה (בתנאי שהיא מאפשרת גישה
לספריות חיצוניות וכו'). זו לא הייתה השאלה. השאלה הייתה בדיוק הפוכה - איך
אפשר לטפל בשגיאות בשפת C, ורק בשפת C, אבל על כל מערכת הפעלה שהיא.
התשובה היא - אי-אפשר. ליתר דיוק - אפשר להשתמש ב-gotos, אבל זה מקומי
לפונקציה, ולא נעים. אפשר לבדוק return codes, אבל זה מטריד ברמות מטורפות,
ובמקרים מסויימים כמעט בלתי-אפשרי.. אפשר להשתמש ב-setjmp/longjmp, מה
שפותר את בעיית המקומיות, אבל יוצר קוד בעייתי למדי. אפשר לממש חיקוי של
C++ exceptions בעזרת setjmp/longjmp, אבל זה מונע אופטימיזציות מסויימות
על כל הקוד, ומבוסס על ה-preprocessor ברמה שפשוט כואבת. בקיצור, אין דרך
נורמלית לטפל בשגיאות בשפת C. פשוט סבל טהור.
(ואני מדגיש שוב - בשפת C בלבד, כך שהוכנה היא fully compliant לתקן, ולא
משתמש בשום פיצ'ר שהוא implementation-defined)

לשאר דבריך:

• הטענה ש-C++ exceptions מבוססים על SEH שגויה. אתה טוען שכן?
  תראה לי את הדיסאסמבלינג שעשית לקוד CPP שמשתמש ב-exceptions
  על כל מהדר CPP לווינדוס שקיים. עד אז, הטענה שלך שגויה.
• SEH לא "חזק יותר". הוא מאפשר טיפול בשגיאות מסוג אחר, שגיאות של
  המימוש, של מערכת ההפעלה. ברור שהתקן לא כולל טיפול בשגיאות כאלה.
  הטענה שלך שקולה לטענה שטיפול ב-signals ביוניקס חזק יותר, כי רק
  הוא מסוגל לתפוס SIGINT ו-SIGSEG...
• מחליף קומפיילרים כל יום? לא, אבל מדי פעם נאלץ. אפילו החלפה אחת
  של קוד שהוא כל-כך תלוי בקומפיילר ספציפי תהיה זוועה. להחליף עשרות
  אלפי שורות קוד שמשתמשות ב-‎__try וכו' יהיה די בלתי-אפשרי, או לפחות
  קשה במידה קיצונית.
• הטענה של Mד שטותית בדיוק כמו שלך. בדקתם את כל הקומפיילרים
  שקיימים לווינדוס? יש לקרוא את המשפט בצורה הנכונה: קומפיילרים אחרים
  עשויים לממש SEH (ולא בטוח שיעשו זאת), ואין שום מגבלה על הדרך
  בה הם יעשו זאת, אם בכלל.

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

סאשה הסוס, סוכן אוסינט.‏

ציטוט:

במקור נכתב על ידי סאשה הסוס לשאר דבריך: הטענה ש-C++ exceptions מבוססים על SEH שגויה. אתה טוען שכן? תראה לי את הדיסאסמבלינג שעשית לקוד CPP שמשתמש ב-exceptions על כל מהדר CPP לווינדוס שקיים. עד אז, הטענה שלך שגויה. SEH לא "חזק יותר". הוא מאפשר טיפול בשגיאות מסוג אחר, שגיאות של המימוש, של מערכת ההפעלה. ברור שהתקן לא כולל טיפול בשגיאות כאלה. הטענה שלך שקולה לטענה שטיפול ב-signals ביוניקס חזק יותר, כי רק הוא מסוגל לתפוס SIGINT ו-SIGSEG... מחליף קומפיילרים כל יום? לא, אבל מדי פעם נאלץ. אפילו החלפה אחת של קוד שהוא כל-כך תלוי בקומפיילר ספציפי תהיה זוועה. להחליף עשרות אלפי שורות קוד שמשתמשות ב-‎__try וכו' יהיה די בלתי-אפשרי, או לפחות קשה במידה קיצונית. הטענה של Mד שטותית בדיוק כמו שלך. בדקתם את כל הקומפיילרים שקיימים לווינדוס? יש לקרוא את המשפט בצורה הנכונה: קומפיילרים אחרים עשויים לממש SEH (ולא בטוח שיעשו זאת), ואין שום מגבלה על הדרך בה הם יעשו זאת, אם בכלל. נסכם: אני צודק, לא נעים לטפל בשגיאות ב-C, ואין בה מנגנון חריגות אמיתי. אתה טועה ומדבר לא לעניין - SEH הוא מנגון ספציפי לקומפיילרים מסויימים על אחת ממגוון רחב של מערכות הפעלה שקיימות. זה לא מאפיין של שפת התכנות C. נסה שוב.

חבל, אתה עוד עלול להטעות אנשים.

המנגנון ב- c++ מבוסס על SEH, בשבילך קישור לדוגמא שמסביר איך מנגנון ה- exception ממומש ב- VC++ :
http://www.codeproject.com/cpp/exceptionhandler.asp
בשבילך אני אצטט:
"VC++ builds its exception handling support on top of structured exception handling (SEH) provided by Windows operating system"

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

SEH חזק יותר, הוא מאפשר כל מה שמאופשר במנגנון המובנה ב- c++ ועוד דברים שלא מתאפשרים שם בעזרת ה- exeption filter . אני ממליץ לך לקרוא קצת על SEH, והנה מדריך קטן:
http://www.gamedev.net/reference/pr...ures/sehbasics/

בשבילך שמרתי ציטוט:

This article explains the fundamentals of using structured exception handling, a Windows-specific technology that offers more power and flexibility and better performance than the C++ exception handling system. The reasons for this framework’s advantages are clear. For one, SEH supports exception filtering. It is possible, using SEH, to resolve a problem inside an exception filter function, or alternatively force the system to ignore this particular instance of an exception and skip it. In addition, SEH in Visual C++ offers an extremely valuable asset – termination handling. With termination handling, you can forget annoying cleanup code and painstaking, repeated return statements. Finally, the technology is available in C code – quite a blessing, really, considering that many applicationss use that language for fast processing. Moreover, C++ exception handling under Visual C++ carries speed and size overhead due to the immense amount of functions that can get called in the process and the data structures required by compilers to pull it off, while SEH, despite some additional functions that the compiler must generate and the OS kernel must call, is fast and reliable because the kernel is responsible for all the cleanup chores and because SEH refrains from making things more complex than they need to be. There is no doubt that in Windows, SEH is faster than C++ EH. Finally, SEH carries with it cross-language compatibility; I can write a DLL that raises a software exception in 2000, and my coworker’s great-grandchildren in 2100, using the magical language called X-Plus, can write a program that uses my DLL and catching the exception it raises. Try that with C++ EH, and you’ll find that it works only in C++ - and even then with possible headaches
because the DLL attaches at runtime.

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

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

נמשיך. כמובן ש-SEH לא "אפשר כל מה שמאופשר במנגנון המובנה ב- c++". נניח שאני רוצה
ליצור אובייקט std::basic_string בעזרת הקונסטרקטור הבא:

קוד:

basic_string(const basic_string& s, size_type pos = 0, size_type n = npos)

כידוע, הקונסטרקטור זורק out_of_range אם pos > s.size()‎. רוצה להראות לי איך אתה
תופס את ה-exception הזה רק בעזרת SEH? אני אשמח ללמוד ממך.

הציטוט האחרון ששמרת עבורי מראה כמה חמור מצבך: למרות המילים המפורשות
בטקסט, אינך מסוגל לקבל, מבחינה נפשית, שיש הבדל בין מה שמאפשרת השפה
למה שמאפשר מימוש ספציפי, וכלל לא מחייב את השפה. הטקסט אומר במפורש
ש-structured exception handling היא Windows-specific technology, ואילו
אתה מצליח בעזרת כוחות רבים (על טבעיים אפילו, הייתי אומר) להתעלם מכך לחלוטין
ולהמשיך לטעון ש-SEH היא תכונה של השפה.

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

סאשה הסוס, סוכן אוסינט.‏

ציטוט:

במקור נכתב על ידי סאשה הסוס זה שקומפיילר CPP אחד, פופולרי ככל שיהיה, בוחר לממש את מנגנון החריגות שלו בעזרת SEH לא אומר שכולם עושים את זה. למען האמת, התקן לא קובע שום דבר כזה לגבי המימוש (לא שאני חודש בכך שאי פעם הצצת בתקן), ואתה רק הראת שקומפיילר אחד עושה את זה. זה שונה לחלוטין מהטענה שאתה ממשיך לטעון: " המנגנון ב- c++ מבוסס על SEH". נמשיך. כמובן ש-SEH לא "אפשר כל מה שמאופשר במנגנון המובנה ב- c++". נניח שאני רוצה ליצור אובייקט std::basic_string בעזרת הקונסטרקטור הבא: קוד: basic_string(const basic_string& s, size_type pos = 0, size_type n = npos) כידוע, הקונסטרקטור זורק out_of_range אם pos > s.size()‎. רוצה להראות לי איך אתה תופס את ה-exception הזה רק בעזרת SEH? אני אשמח ללמוד ממך. הציטוט האחרון ששמרת עבורי מראה כמה חמור מצבך: למרות המילים המפורשות בטקסט, אינך מסוגל לקבל, מבחינה נפשית, שיש הבדל בין מה שמאפשרת השפה למה שמאפשר מימוש ספציפי, וכלל לא מחייב את השפה. הטקסט אומר במפורש ש-structured exception handling היא Windows-specific technology, ואילו אתה מצליח בעזרת כוחות רבים (על טבעיים אפילו, הייתי אומר) להתעלם מכך לחלוטין ולהמשיך לטעון ש-SEH היא תכונה של השפה. אני מציע לך לוותר בשלב הזה ולהפסיק להביך את עצמך עם הטענות השטויות שאתה בעצמך סותר. למה שלא תלך ותקרא את התקן של C? אולי בטעות תלמד משהו.

התקן תלוי בשלט ענק מעל המיטה שלי תודה רבה

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

עכשיו אחרי שהבהרתי את זה, בשום פוסט שלי לא כתבתי ש- SEH זה לא windows specific technology.. אני אמרתי את זה מהפוסט הראשון שלי בדיון הזה וגם בכל השאר או לפחות בחלק, ובשום מקום לא טענתי אחרת. זה לא מנגנון בנוי בשפה כמו זה שב- c++ אבל זו אפשרות קיימת לטיפול בשגיאות בזמן ריצה בישומים רבים, זהו מנגנון מוכר ומספיק אנשים כותבים תוכניות ל windows ככה שזה נראה לי טיפשי להתעלם מכך. חוץ מזה שגם הזכרת את חוסר המנגנון הבנוי בשפה כסיבה לא להתחיל ללמוד לתכנת ב- c אלא בשפה אחרת.. על זה לא הגבתי אבל זו לא סיבה הגיונית למתחיל לא ללמוד c תחילה.

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

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

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

אה ומן הסתם אי אפשר לתפוס עם SEH חריגה שנזרקה מהמנגנון ב- c++ וכך ממומש הטיפוס basic string נכון? באותה מידה אם אני אכתוב class אחר ובקונסטרקטור שלו אזרוק חריגה באמצעות SEH לא יהיה ניתן לתפוס אותה באמצעות המנגנון ב- c++ (ותקן אותי אם לא הבנתי את המצב נכון).

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

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

"מן הסתם אי אפשר לתפוס עם SEH חריגה שנזרקה מהמנגנון ב- c++", ולכן הטענה
שאתה חוזר עליה, "SEH חזק יותר, הוא מאפשר כל מה שמאופשר במנגנון המובנה
ב- c++ ועוד דברים שלא מתאפשרים שם" היא שטות מוחלטת - אי אפשר לעשות עם
SEH כל מה שעושים עם C++ excetions. מצד שני, הטענה שלי, כרגיל, נכונה לחלוטין:
"SEH לא "חזק יותר". הוא מאפשר טיפול בשגיאות מסוג אחר, שגיאות של המימוש,
של מערכת ההפעלה. ברור שהתקן לא כולל טיפול בשגיאות כאלה. הטענה שלך שקולה
לטענה שטיפול ב-signals ביוניקס חזק יותר, כי רק הוא מסוגל לתפוס SIGINT ו-SIGSEG."
אגב, שיטה מקובלת בעולם האמיתי לטפל ב-SEH exceptions היא ליצור translator
שמתרגם SEH exceptions ל-C++ exceptions, ובקוד לטפל ברק באחרונות.
הטענה שלך לגבי C++ exceptions ו-SEH exceptions שקולה גם לטענה שצוללת
היא כלי רכב חזק יותר ממטוס, כי היא יכולה להגיע לעומק רב יותר מתחת לפני הים,
ולמי אכפת מזה שהמטרות שלהם שונות לחלוטין?

סאשה הסוס, סוכן אוסינט.‏

זה לא שגיאות מסוג שונה, זו פשוט העובדה שמנגנון אחד לא יכול לעבוד עם מנגנון שני.
ה try ו throw הוא ב c++ exception , אם הייתי מממש טיפוס מסויים והייתי זורק איתו חריגה ב- SEH אז היה אפשר לתפוס אותה רק עם SEH, ולא זו לא חריגה מסוג שונה. אם תממש עבור קלאס סטרינג שלך חריגה ב- SEH ולעומת זאת תממש חריגה ב c++ exception, תוכל לעשות ב- SEH יותר ממה שב- c++ exceptions וזה יהיה יותר מהיר. קאפיש? אל תסלף את הדברים שלי בבקשה.

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

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

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

נתחיל מהעובדות הפשוטות:

• עובדה: SEH לא מסוגל לתפוס C++ exceptions. נקודה.
• עובדה: בכל קוד בעולם האמיתי יש צורך לתפוס C++ excpetions (כי משתמשים
  בספריה הסטנדרטית של C, או בכל ספריית הרחבות OO-ית, כמו boost ו-zthread
  ואפילו MFC ו-ATL של MS עצמה). נקודה.
• עובדה: SEH לא מסוגל לתפוס את החריגות הללו. נקודה.
• עובדה: SEH איננו "יותר חזק" מ-C++ exceptions, ואפילו לא מסוגל לספק את
  כל התפקודיות שאלו מספקות. נקודה.
• עובדה: C++ exceptions הן כאן ויישארו כאן. המצאות משעשעות של מימושים
  משעשעים הם נחמדים וחשובים, אבל אינם תחליף למגנון הסטנדרטי לטיפול
  בשגיאות של שפת C++‎. נקודה.

האנלוגיה שלך שגויה. כדאי שתלמד איך עושים אנלוגיות. הנה אחת טובה יותר, ד"ר
ספק-ממ"סניק-בגרוש:

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

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

סאשה הסוס, סוכן אוסינט.‏

ציטוט:

במקור נכתב על ידי סאשה הסוס נתחיל מהעובדות הפשוטות: עובדה: SEH לא מסוגל לתפוס C++ exceptions. נקודה. עובדה: בכל קוד בעולם האמיתי יש צורך לתפוס C++ excpetions (כי משתמשים בספריה הסטנדרטית של C, או בכל ספריית הרחבות OO-ית, כמו boost ו-zthread ואפילו MFC ו-ATL של MS עצמה). נקודה. עובדה: SEH לא מסוגל לתפוס את החריגות הללו. נקודה. עובדה: SEH איננו "יותר חזק" מ-C++ exceptions, ואפילו לא מסוגל לספק את כל התפקודיות שאלו מספקות. נקודה. עובדה: C++ exceptions הן כאן ויישארו כאן. המצאות משעשעות של מימושים משעשעים הם נחמדים וחשובים, אבל אינם תחליף למגנון הסטנדרטי לטיפול בשגיאות של שפת C++‎. נקודה. האנלוגיה שלך שגויה. כדאי שתלמד איך עושים אנלוגיות. הנה אחת טובה יותר, ד"ר ספק-ממ"סניק-בגרוש: מכונית א' נוסעת רק על כבישים עירוניים, בכל מדינה שהיא. מכונית ב' נוסעת רק על כבישים בין עירוניים, רק במדינה אחת. אפשר לשפצר בקלות את מכונית א' כך שתיסע גם על כבישים בין עירוניים במדינה שבה נוסעת מכונית ב. אתה טוען שמכונית ב' "חזקה יותר" כי אם נמצאים במדינה מאוד מסויימת, אז מכונית ב' יכולה לנסוע מהר יותר בכבישים בין עירוניים - למרות שהיא לא יכולה לנסוע על כבישים עירוניים, שלא לדבר על מדינות אחרות...

איפה טענתי ש SEH כן מסוגל לתפוס exception של המנגנון ב- c++? לא הבנת את האנלוגיה על הסולר והבנזין?
במקומות שיש לך קוד כתוב מראש עם try ו- throw של c++ אז צריך לתפוס את זה מן הסתם עם המנגנון של C++, לא טענתי אחרת, ואיפה התפקודיות הנוספות שהמנגנון ב- c++ מספק? ההפך. אותו הדבר עם SEH אבל אם אתה כותב בעצמך class, אז SEH יהיה יותר מהיר ויאפשר יותר בגלל ה- filter function. בשום מצב אם תתחיל לזרוק קלאסים המנגנון ב- c++ לא יהיה מהיר כמו SEH. תתחיל להתייחס לטענה הזאת שלי בבקשה.

לא הבנתי את האנלוגיה ואת מה שעומד מאחוריה. אה וזה זילזול בממ"סניקים?
אני רק מלש"ב ואני גם לא מיועד לשם ואין לי שמץ מאיפה הבאת את זה.

לסיכום, כל מה שאמרתי זה שהתעלמת ממנגנון מוכר שמשתמשים בו בשפת c לטיפול בשגיאות, הוא לא מובנה בשפה ולא כתבתי את זה בשום מקום אבל משתמשים בו בעיקר בשפת c (ולא c++) ואי אפשר להתעלם ממנו כי מפתחים מספיק ישומים לווינדוס. זריקת exception כלשהו במנגנון SEH היא יותר מהירה מבמנגנון ב - c++ (ותכתוב שלא אם אתה באמת חושב כך, אבל אתה יודע שזה נכון).

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

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

התחלת עם:

ציטוט:

במקור נכתב על ידי bla27 איפה טענתי ש SEH כן מסוגל לתפוס exception של המנגנון ב- c++?

אז איפה באמת? כאן:

ציטוט:

במקור נכתב על ידי bla27 אז SEH עושה כל מה שהמנגנון ב c++ עושה ויותר

וכאן:

ציטוט:

במקור נכתב על ידי bla27 ניתן להשתמש במנגנון הזה, ולכל "סוגי" החריגות, מן הסתם לא רק של מערכת ההפעלה

ועכשיו המצב בעולם האמיתי: SEH לא מטפל ב-C++ exceptions, אבל בקוד
בעולם האמיתי דווקא יש C++ exceptions. מסקנה: SEH לא "כל מה שהמנגנון
ב c++ עושה", ובטח שלא יותר. אם SEH היה יכול לעשות הכל, לא היה לנו צורך
ב-C++ exceptions. זה כמובן לא המצב.

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

עם כל האב, נסביר את הדברים:

• מכונית א' (C++ exception handling) נוסעת רק על כבישים עירוניים
  (C++ exceptions), בכל מדינה שהיא (כל מימוש שתואם את התקן).
• מכונית ב' (SEH) נוסעת רק על כבישים בין עירוניים (SEH exceptions),
  רק במדינה אחת (ושמה בישראל: ווינדוס; ורק שני קומפיילרים בפועל,
  ולא כולם כמו שטענת למעלה).
• אפשר לשפצר בקלות את מכונית א' כך שתיסע גם על כבישים בין
  עירוניים במדינה שבה נוסעת מכונית ב (אפשר לכתוב רכיב קטן
  שמתרגם SEH exceptions ל-C++ exceptions).

אתה טוען שמכונית ב' (SEH) "חזקה יותר" (ציטוט מדויק) כי אם נמצאים במדינה
מאוד מסויימת (ווינדוס), אז מכונית ב' (SEH) יכולה לנסוע מהר יותר (נקבל את
הטענה ש-SEH מהיר יותר) בכבישים בין עירוניים (SEH exceptions) - למרות
שהיא לא יכולה לנסוע על כבישים עירוניים (C++ exceptions, שקיימים בכל קוד
אמיתי), שלא לדבר על מדינות אחרות (נגיד, Intel, Watcom, שלא להזכיר מערכות
הפעלה שאינן ווינדוס)...

אגב, אם היית טורח להציץ באתר gamedev, שאילו הפנית למעלה, היית רואה את הדברים הפשוטים הבאים:

Note that SEH is not portable but a VC++ specific implementation. Other compilers may support SEH but it is not guaranteed.

כמובן שלא טרחת לקרוא וללמוד. לא חשבתי אחרת.

האשמת אותי בסילופים יותר מפעם אחת:

ציטוט:

במקור נכתב על ידי bla27 קאפיש? אל תסלף את הדברים שלי בבקשה.

ציטוט:

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

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

סאשה הסוס, סוכן אוסינט.‏

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

בקוד חדש שאתה כותב, אתה בעצמך יכול לכתוב try ו- catch עם שימוש ב SEH ואז זה יהיה יותר מהיר ויאפשר יותר. שוב.. תתייחס לטענה הזאת כבר.

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

ועל זה לא התחיל הויכוח, זה סתם התפתח אחרי שהתעלמת ממנגנון מוכר שאפשר להשתמש בו לחריגות לווינדוס. זה לא סוג שונה של חריגה, בקוד כתוב מראש אולי הוא ממומש רק עבור פונקציות של ווינדוס, אבל אתה בעצמך יכול להשתמש בו למה שאתה רוצה. השימוש בו יהיה יותר מהיר ויאפשר יותר מהמנגנון ב c++ (ושימוש בו כולל=שימוש בו= try ו- throw של SEH מן הסתם). חוץ מזה שב- C אין לך באמת את הבחירה בין שני המנגנונים אבל אם כן הייתה, ואני לא מתייחס לקוד כתוב מראש אז הרבה יותר מהיר ב SEH.

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

SEH לא עושה את כל מה שמנגנון ה-exceptions של C++‎ עושה. SEH לא מסוגל לתפוס
ולטפל ב-C++ exceptions (וזה בלי להיכנס למאפיין החשוב באמת שאין ל-SEH).

את השטות על "סוגי פסיקות" אתה המצאת. זה לא סילוף, בניגוד להאשמות שהטחת כלפי,
אלא סתם שקר. הפעם הראשונה בה המילים "סוגי פסיקות" הוזכרו באשכול הזה הייתה
בתגובה האחרונה שלך. חיפוש בעמוד יוכיח את זה. אני מבין שקשה לך להתמודד עם זה
ש-SEH נועד למטרה אחרת לחלוטין ממנגנון ה-exceptions של C++‎, שהיכולות שלו שונות
לחלוטין, ושיש להשתמש בו במקרים אחרים לגמרי, אבל זו ממש לא סיבה להתחיל לשקר.
תשתלט על עצמך!

למה שלא תקרא קצת על SEH?

סאשה הסוס, סוכן אוסינט.‏

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

אף פעם לא טענתי ש SEH תופס שגיאות c++ ושאמרתי יותר דיברתי על כאשר באמת משתמשים במנגנון לזריקת שגיאות.

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

תוך כדי הטחת עלבונות ילדותיים שמראים עליך הרבה מאוד, אולי יותר ממה שהתכוונת להראות.

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

סאשה הסוס, סוכן אוסינט.‏

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

https://www.youtube.com/watch?v=0HRGczvZINQ&noembed

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

#define MACRO(x) hello(x)

מבצעת משהו שונה לחלוטין מאשר זו

#define MACRO (x) hello(x)

הגיוני? אולי אם אתה מהדר C...

סאשה הסוס, סוכן אוסינט.‏

מנגנון המקרו הוא הוא לא מנגנון של הקומפייליר אלא של ה- pre-processor שזה תהליך שרץ לפני הקומפילציה. הוא לא מתיימר להיות תהליך חכם - סך הכל מחליץ את המקרויים בערכים שלהם ב- define - דבר ש text editor פשוט עושה. אתה לא חייב להשתמש מנגנון הזה - אפשר להגדיר קבועים גלובליים וכו. הסיבה היחידה שמשתמשים בו זה יעילות - פשוט כדי לא לקבוע ערך של משתנה בזמן ריצה אלא לפני קומפילציה

הגיוני? אולי יותר...

ומי שקורא גם יודע:

The C preprocessor, also added about this time at the suggestion of
Alan Snyder, fulfilled three main purposes:

• String replacement, of the form "change all foo to baz", often
  to provide a symbolic name for a constant.
• Source file inclusion (as pioneered in BCPL). Common declarations
  could be separated out into a header file, and made available to a
  range of source files. Though the ".h" convention was adopted for
  the extension of header files, unhappily no convention arose for
  relating the header file to the object library that contained the
  corresponding code.
• Expansion of general code templates. Unlike a function, the
  same macro argument can take different types on successive
  calls (macro actual arguments are just slotted unchanged into
  the output). This feature was added later than the first two, and
  sits a little awkwardly on C. White space makes a big difference
  to this kind of macro expansion.

אתה יכול גם להסתכל על סדר תת הסעיפים של סעיף 6.10 בתקן.

סאשה הסוס, סוכן אוסינט.‏

בבקשה תפסיק להתווכח עם דברים שלא אמרתי.

כתבת "זה" בהתייחס לדבריו של DaveM, שדיבר על "מנגנון המקרו ... של ה- pre-processor" בהתייחס לדוגמת קוד פשוטה מאוד שלי:

#define MACRO(x) hello(x)


#define MACRO (x) hello(x)

דגכגד. ברור לחלוטין שבדוגמת הקוד הזו לא מתבצעת החלפה טקסטואלית פשוטה, וגם לא source file inclusion, אלא "Expansion of general code templates". לא יעזור לך. זה שאתה מגיב בלי קשר למה שאומרים לך זו בעיה שלך.

סאשה הסוס, סוכן אוסינט.‏

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

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

סאשה הסוס, סוכן אוסינט.‏

יאללה ילדודעס, להפסיק לריב, ההפסקה נגמרה, כולם להכנס חזרה.

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

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

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

סאשה הסוס, סוכן אוסינט.‏