אתם מלאים דעות קדומות על VB !

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

לאומת זות VB היא שפה מסודרת וקלה ללימוד ,וניתן לבנות בה
כל מה שאפשר לבנות ב C,ו C++.

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

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

VB היא המצאה של Microsoft כדי שיהיה נוח לכתוב ממשקי משתמש בקלות רבה, ללא מאמץ, וזה הכל...
בכל הנוגע לתיכנות אמיתי (כלומר, החלק העיקרי של התוכנה), נשאיר את זה ל- ++C/C...

1. ב-VB א"א לעשות את כל מה שאפשר לעשות ב-C.
מעצם זה שהן שונות.

2. אין שום בסיס לטעון על סמך 1 ש-VB חלשה מ-C.
אפשר באותה מידה לטעון את ההיפך, וזה יהי שגוי באותה מידה.

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

4. הצעות בעיתון לא משקפות כלום.
עובדה, יש הרבה הצעות לעבודה תחת ווינדוס, וכלנו יודעים שווינדוס בעמדת נחיתות עצומה לעומת לינוקס( או GNU/LINUX, או יוניקס) מכל הבחניות מלבד התמיכה הרחבה של חברות המשחקים בווינדוס בלבד.

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

6. כמו שהוכחתי לעיל, אין לך ניסיון, וזה אומר ש:
*אין לך זכות לבוא ולדבר על אחרים באופן כזה:"אתה פשוט מדבר שטויות...ורואים שאין לך נסיון !!!אם אתה לא יודע ++C/C, אל תבלבל ת'מוח שב-VB ניתן לעשות כל מה שאפשר ב- ++C/C, כי לא כך הדבר."
*אין לך זכות מוסרית לעשות את זה.
ההתחבאות מאוחרי השמלה של DRYICE מראה על כך שאין לך שום טיעון רציני.

7. ושוב אני חוזר לנושא, אחרי שסטיתי ממנו.
היתרונות של C לעומת VB:
*יותר שליטה על "מאחורי הקלעים".
*עליונות מבחינת מהירות ביצוע(לא תמיד).
*נפוצה יותר.
*תמיכה רחבה יותר.
*תמיכה בפלטפורומות מרובות(עם בעיות).
*ועוד...

8. כל זה טוב ויפה, בלי להתחשב ב:
*אין פורמט בינארי(צרות).
*פיתוח הרבה יותר קשה וארוך(עוד צרות).
*סיכוי הרבה יותר גדול לשגיאות.
במיוחד מצד "תוכניתנים" בלתי-מנוסים(ורוב "תוכניתני" C הם כאלה).(הרבה צרות!)
*לא נוח ליצירת ממשקי משתמש גרפיים "עשירים".(עוד קצת צרות)
*ממש לא נוח ליצירת אפליקציות אינטרנט/e-commerce(נחש...)
*ממש ממש לא נוח ליצירת אפליקציות n-tier(וואלק?!)

9. וכאן נכנסת VB, אנחנו מקריבים ביצועים כדי לקבל:
*פיתוח יותר מהיר.
*פחות שגיאות.
*נוח ליישומי אינטרנט.
*נוח ליישמוי n-tier(תוך שימוש ב-ActiveX/COM).
*יצירת משתמש סביר למדי קלה מאוד.

Java זה תיכנות תחת פלטפורמת Windows, וכידוע לך, המשחקים שציינת עובדים תחת Dos...
האמת היא שאפשר לעשות משחקים כאלו גם ב-Pascal וכו'... (כל אלה שתאימים ל-Dos).

איך אתה מעז לטעון שאתה יודע מה טוב ומה לא?
כשאתה לא יודע דבריפ פשוטים כמו:

"Java זה תיכנות תחת פלטפורמת Windows"
WTF?
JAVA?
ווינדוס?
לא שמעת על אי-תלות בפלטפורמה, הססמה של JAVA?

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

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

כשאתה יודע C, אתה יודע פחות או יותר איך המחשב עובד... במיוחד כשיש גם תמיכה בכתיבה בקוד אסמבלי...
VB זה כמו צייר, או כל תוכנה וויז'ואלית של Microsoft...
יש איזה סביבת עבודה, אני לא יודע אם שמעת, אשר נקראת Dark-Basic, שהיא סביבת פיתוח למשחקי תלת-מימד דרך DirectX... אם תסתכל על הרמה של התיכנות, אף על-פי שניתן ליצור משחק של ממש רק בכ-500 שורות קוד, הרמה ממש נמוכה, וזה בדיוק מזכיר את VB...

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

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

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

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

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

תאמין לי, אני יודע טוב מאוד על מה אני מדבר... ומבחינת הרמה, זה כמו צייר (מטאפורה).

בקשר לדבריך, ברור שאפשר לבנות (כמעט) כל תוכנה ב-VB, אבל השאלה היא עד כמה יעיל, וכשזה נוגע ליעילות, אין כמו ++C/C, ועל זה אתה לא יכול להתווכח (מבחינת זה ש-VB יכולה להיות מתחרה).

בכל מקרה, כשהתכוונתי שאת הממשק בונים ב-VB, כי זה מאוד פשוט (שוב פעם, כמו בצייר), ואת התוכנה עצמה בונים ב- ++C/C, התכוונתי שמשלבים DLL של ++C/C בתוכנית ממשק של ה-VB שאתה יוצר...

כרגע אני גם עובד על פרוייקט (תוכנית סביבת עבודה ל- BrickOS - תכנות ב- ++C/C לרובוטים של לגו) שהממשק שלו זה VB, אבל חלק עיקרי וגדול מאוד מהתוכנה כתוב ב-DLL של ++C/C...

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

אני יודע בעיקר VB וקצת C/C++
VB קלה לשימוש אבל היא לא שפה חזקה
כמו C שיש לה יתרונות בכתיבה עצמה

אבל באו Microsoft לפני כמה זמן והביאו לנו את .NET עם:
VB.NET
C++.Net
C#
שלושתם עובדים על אותם DLL's מה שהביא את VB לביצועים כמו של C
בין השאר אפשר לכתוב משולב, באותה תוכנה אתה יכול לכתוב גם בVB
גם בC++ וגם בC# ככה שכל החסרונות של VB נעלמות פתאום..
גם M$ שינו את התחביר קצת של VB והוסיפו המון אבל המווון אופציות
ואני לא מדבר על מימשק משתמש אלה על אפשרויות של איזה דברים אתה יכול להכניס בתוכנה שלך..

החסרון היחיד של .NET שצריך להתקין אותו במחשב קודם - 20 MB

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

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

עכשיו לעניין:
אני לא אחזור על הטענות שלי שמסבירות למה הטיעון של "VB חלשה" הוא אידיוטי(כמה הודעות למעלה), אלא אנזה לרשום מתי כל שפה מתאימה.

C/CPP
מתאימה במיוחד ל
*כתיבת מערכות הפעלה,
*דרייברים(לווינדוס),
*מערכות DSP,
*מערכות RT.
זה ככלל, יש עוד הרב מקרים בהם השפות הללו מתאימות, אבל לפעמים יש שפות שעדיפות.
(לא עשיתי הבחנה בין C ל-CPP כי ברוב המקרים התחומים שלהם חופפים)

VB
*יצירת יישומים בעלי "יותר" ממשק משתמש ו"פחות" גישה לחומרה/כל מה שאמרנו בסעיף של C/CPP.
*רק לווינדוס.
*מתאים מאוד לגישה למסדי נתונים.
*מערכות שרת/לקוח.
*מערכות E-BIZ.
*מערכות n-tier.
(*כל דבר שדומה ל-3 הסעיפים למעלה)
ועוד...

JAVA
כמו VB, אבל -
*אי-תלות בפלטפרומה.
*ממשק משתמש קצת יותר מסובך, אבל יעיל יותר(מבחינת ביצועים).
*יותר מונחה אובייקטים(מ-VB6).
ועוד...

טוב, זה מספיק שפות לעכשיו(ולא השקעתי ב-JAVA, שאפשר לעשות איתה הרבה יותר).

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

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

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

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

אם אתה חושב ש-VB היא כמו צייר(מברשת צבע), אתה לא יודע כלום על VB.
ומעולם לא ניסית לכתוב מערכת n-tier מבוזרת שמשתרעת על פני 3 יבשות ב-C...

אני מכיר את DarkBasic מזמן, ולפי מה שראיתי זו לא "סביבית עבודה" אלא שפה שונה מאוד, שדומה בתחביר ל-QB.

C לא חזקה יותר.
לא הוכחת כלום.

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

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

2. NMOS הוא מבנה הזיכרון, שפועל בדיוק על העיקרון של TTL, כמצויין לעיל, אם אני לא טועה.

3. לא, לא כל הרגיסטרים נגישים למתכנת. האמת היא שלא התעמקתי בזה כל כך, אבל לפי מה שאני יודע, הרגיסטרים PC (מונה תוכניות), ALU ו-MAC אינם נגישים, והם כמו Private של המעבד.

4. ממש אין לי כוח

5. מנגנון Two's Complement, הוא המנגנון אשר אחראי על כל הפעולות שמתבצעות על מספרים, כשמעורב בהם סימן המינוס (-), כלומר מספרים שליליים. המנגנון הזה הכרחי, בגלל הבעייתיות שבייצוג מספרים שליליים בבינארי. ייצוג מספרים בינארי כבר נידון פה בעבר, אז אין טעם שאני אחזור על זה.

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

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

תקרא את מה שכתבתי בסוף. שם הבהרתי את כל הדברים שנאמרו קודם, במיוחד על ידי. בכלליות, התכוונתי שה-Syntax, והאפשרויות הרבות שנלוות לשפה, הוא שהופך את ++C/C להיות חזקה. אני לא יודע מה איתך, אבל לדעתי, ה-Syntax של Basic, ממש ברמה נמוכה, כמו גם האפשרויות שהוא מקנה.

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

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

אני יתן לך דוגמה לשילוב ההכרחי בין VB ל-++C/C.
נניח שאתה רוצה לבנות תכנית לכתיבת קוד, כמו ++Microsoft Visual C, אתה לא תבנה הכל ב- ++C/C, כי זה ממש מסובך. את הממשק - כל התפריטים, הכפתורים, הטפסים עצמם, אתה תבנה ב-VB, כי זה ממש פשוט, וזה גם לא דורש יעילות מיוחדת. זה מה שאני עושה כרגע. אבל כך לדוגמה את תיבת הטקסט בה אתה כותב את הקוד. נסה לכתוב קוד שיגרום לתיבת הטקסט הזאת (או יותר נכון Rich Text Box, כי אתה זקוק לצבעים) להתנהג כמו זו שב- ++Microsoft Visual C (מבחינת העניין של זיהוי מילות מפתח, צביעה שלהן וכו'). אני ניסיתי ב-VB, וזה היה ממש איטי - זה גרם להקלדה להיות איטית, ותאמין לי, עשיתי את זה סופר-יעיל. מה שנשאר, זה לבנות פקד אחר, ב- ++C/C, ולשלב אותו בתוכנית. בסוף, זה מה שעשיתי, שילבתי את הפקד בממשק המשתמש שבניתי ב-VB, ועכשיו, הכל עובד מצויין.

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

יש לך טעות ב-2, אבל לא משנה...
הענייןה או שלא נראה לי שהידע הזה בא מכך שאתה מתכנת ב-C.

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

זו טענה סתמית בלי שופ הוכחות או אפילו עדויות(אפילו לא נסיבתיות!), אז למה לטעון טענות שווא כאלה?

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

אין שום סיבה לא לכתוב את כלל היישום ב-VB.
לדוגמא, יש בעיה לכתוב תוכנה כמו מירק ב-VB?
יש בעיה לכתוב את ICQ ב-VB?
את MSN MSNGR?

לידיעתך, מכובדי, בתעישה האוירית כותבים תוכנות לבדיקה של מכשירים ב...VB!

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

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

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

3. הדוגמאות שאתה מביא לא יעזרו לך. ברגע שהבאתי לך דוגמה אחת (Microsoft Visual C), "סטראוטיפ" להרבה דוגמאות אחרות, כל דוגמה שתביא תהיה לשווא. VB לא יעילה, ולכן, יש דברים, והרבה, שאי-אפשר ולא-ניתן לעשות בה.

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

5. VB היא שפה חלשה, מבחינת הרבה דברים.
אין דבר שלא תוכל לעשות ב-VB, שאי-אפשר לעשות גם ב-C, אבל כמה חבל, זה לא הפיך.
אם אתה רוצה לדעת, המהדר נקשר באופן אוטומטי לסביבת הפיתוח, ככה שכאשר מדברים על VS.Net, מדברים על Framework, וכו'.
אם אתה רוצה לדעת, ה-Begin/{ וה-End/} ממש לא קשורים, ואתה יכול להבין לפי מה שכתבתי למעלה...

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

1. אולי. מצטער.

2. אני אחזור לזה בסוף, כי זה ארוך.

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

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

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

6. לא אמרתי שאני לא מתכנת ב-C, למרות שזה נכון, אני מעדיף את CPP לרוב היישומים המעשיים.
אני פשוט לא ***מגדיר את עצמי*** כמתכנת C.
זה לא סותר בכלל את העובדה שאני עובד עם CPP.

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

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

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

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

ד) ומה רע בזה???

ה) handle עצמי?
מי זה אני?
אם אני זו פונקציה אפשר לקבל את הכתובת שלה(אתה טועה).
אם אני זו מחלקה אפשר לקבל את הכתובת שלה(אתה טועה).
אם אני זו התוכנה א"א לקבל מצביע אליה(אתה צודק, אבל א"א לעשות את זה בשום שפת תכנות).

1. טוב שהבנת.

2. כנ"ל.

3. בדיוק !!! הפקד הזה לא יעיל !!! ומה המסקנה ??? לעשות פקד ב-++C !!! בטח לא ב-VB...

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

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

6. אתה יודע ++C, אבל לא יודע C ??? שמעת על דבר כזה שנקרא סדר-עבודה ??? לא ??? נו-טוב...

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

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

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

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

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

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

3. הפקד הזה לא קשור ל-VB.
הפקד עצמו נכתב ב-CPP לידיעתך.
אז מה?
פקדים בנכתבים ב-CPP לא יעילים?
מה זה מוכיח?
רק את ההפך ממה שטענת!

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

5. בוא נעבוד בשיטה לוגית:
ב-CPP אפשר לעשות את כל מה שאפשר לעשות ב-VB; ב-VB א"א לעשות את כל מה שאפשר לעשות ב-CPP.
|
|
V
ב-CPP אפשר לעשות יותר דברים מב-VB.

***זהו אינו מדד ל"כוח" של השפה.***
באסמבלי אפשר לעשות יותר דברים מב-CPP(יותר יעיל, אין בעיות של טיפוסים לא תואמים בין מהדרים, הרבה דברים נחמדים...) - זה לא אומר ש-ASM יותר חזקה מ-VB.

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

6. איפה רשמתי שאני לא יודע C?
האם אתה טיפש?
כאן אני לא אוותר על מיילים בוטות!
איפה רשמתי שאני לא מתכנת ב-C???
אתה מעוות את דברי ושם מילים בפי.
אתה יותר חצוף ושקרן ממה שתיארתי לעצמי!

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

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

ב) ה-LOADERים של תוכניות הכתובות ב-CPP פועלים אחרת מה-LOADR של VB.
אבל "בפועל, במעבד ובזכרון" מה שרשום(אפילו ב-VB) זה מה שקורה).

ג) פה הוויכוח חסר תועלת.
האם שמעת של stroustrup?
האם שמעת על הספרים Effective C++
More Effective C++
The Design and Evolution of C++
?
תקרא אותם אולי תחכים.

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

ה) אתה מראה את בורותך ואת נכונותך לדגול בכל אמצעי על מנת להעליב את מי שאת מחשיב כיריב שלך.
כ"כ פתטי!
אתה טוען:
*שאני לא יודע מהו handle.
*שאם הייתי באמת מתכנת ב-CPP הייתי נתקל במושג.
*שזה שאני לא יודע מהו handle נובע מכך שאני מתכנת VB עלוב, ומראה כמו-כן איך זה שאני מתכנת VB עלוב גורם לי לא לדעת איך המחשב פועל.
*שב-VB ה-handleים הם אוטמטיים.
*שב-VB א"א להגדיר handleים כי א"א להגדיר מצביעים.
*בזמן ריצה אפשר להחזיר את כתובת תוכנית.
*כתובת התכנית היא ה-MAIN שלה.
*פקד עובד בעזרת handleים.
*handleים בונים ב-CPP.

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

*אין שום קשר בין CPP לידיות.
עד שלא תוכיח שיש קשר כזה הוא לא קיים.

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

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

*לדוגמא:
ישנן פונקציות API שאחד הפרמטרים שלהן הוא ידית לפונקציה.
זה נקרא, אם לא ידעת מנגנון CallBack Function.
כדי להשיג את הידית(שבמקרה הנ"ל היא מצביע, LPVOID עד כמה שאני זוכר) משתמשים באופרטור AddressOf על הפוקנציה שזקוקים לידית עליה, מכניסים את התוצאה למשתנה מסוג LONG, ושולחים ל-API.

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

*ב-VB אין MAIN.
בקובול אין MAIN.
ב-ASM אין MAIN.
בפורטרן אין MAIN.
בלוגו אין MAIN.
על מה אתה מדבר?

בוא נניח שהתכוונת ל-C.
לטענתך "כתובת התכנית" היא הכתובת של נקודת הכניסה שלה?
הנה מחשב תיאורטי שבו הנתונים של התכנית נשמרים לפני קוד התכנית(DS קטן מ-CS, וזה בהנחה שאני עובד עם Segmented Addresses, אבל רציתי להשתמש במונחים מוכרים, כדי לא לבלבל אותך).
אז הכתובת לתכנית היא לפני הכתובת לנקדות הכניסה!

*נכון. פקדי ActiveX אכן עושים שימוש נרחב בידיות.
אבל מה זה מוכיח ואיך זה קשור אלינו?

*handlים לא בונים ב-CPP.
ידית היא מונח אבסטרקטי.

בברכה...
או שלא!

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

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

מדברים על שפות סף, כי אם על שפות עיליות, כמקובל היום, כולל את ++VB/C/C וכו'..., ולכן, כשמדובר בשפות עיליות, ++C/C חזקות מ-VB... אתה

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

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

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

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

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

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

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

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

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

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

למציאות, ולא ממושת כמעט כלל ב-VB.

ג) אני אחזור על עצמי שוב. חפש ב-Google, יש המון מאמרים על זה, ואני בטוח שתמצא את הפיתרון הרצוי.

ד) טוב שהבנתי את כוונתי.

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

מבחינת התיכנות.
פלטרפומת ה-Win32, בנוייה כמערכת קלינט/שרת, כאשר הקלינט הוא התוכנה, והשרת הוא ה-Windows עצמו. מערכת השרת, נועדה לטפל ולנהל את

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

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

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

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

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

למשל פועלים הפקדים של ה-VB, שהרי נבנו ב- ++C. הם מקבלים מידע אודות המתרחש סביבם בכל הנוגע אליהם, ומבצעים פעולות.
בכל מקרה, ה-Handle עצמו, צריך וחייב להיות פונקציה שהערך המוחזר ממנה יהיה מסוג פוינטר (לרוב *void), זאת לשם ביצוע הפעולות הנדרשות

שממומשות ב-CallBack Function.
בקשר לפונקציות API שדיברת עליהן. נו הרי בוודאי שהן CallBack Function, כי הן חלק מהמערכת של השרת, ולכן המנגנון שלהן משותף למנגנון

הכללי של השרת.

* עכשיו, בקשר לקשר ל- ++C.
תגיד לי, או תן לי דוגמה אחת, ורק אחת, על כך שמתכנת VB (לא ++C/C וכו') היה יודע את הנ"ל, והרי הנ"ל הוא מה שקורה בפועל, בלי קשר ל-

++C/C. הרי ב-VB אין לך פונקצית Handle כלשהי שאחראית על הטיפול ב"שיגרות" או "אירועים" וכו'. הכל "אוטומטי", ולכן מתכנת VB לא מודע למה

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

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

ציינתי קודם.

* אכן ב-VB ה-Handle הוא אוטומטי, ולא ממומש על ידי המתכנת, כמצויין לעיל.

* נכון מאוד, אתה לא יכול להגדיר ב-VB פונקצית Handle, בין היתר בגלל שב-VB אין אפשרות להשתמש במצביעים (וגם עוד המון סיבות אחרות,

שקשורות למופשטות שב-VB, לאוטומטיות שבה).

* אכן בזמן ריצה, ניתן להחזיר את כתובת התכנית. מה זה כתובת התוכנית ?, נקודת ההתחלה שבקטע הקוד (_CODE), ואם אתה מתכנת C, אתה גם

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

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

היית מבין זאת כבר בהתחלה.

* כנ"ל.

* פקד אכן עובד עם Handlים, ונדמה לי שציינתי את זה למעלה.

* Handle הוא כפי שציינתי לעיל, מושג, בדיוק כמו ש"פונקציה" היא מושג, ולכן, כן בונים אותם ב- ++C/C וכבר נתתי לך דוגמה. אם אתה רוצה, יש לי עוד

הרבה דוגמאות ל-Handleים שיכולים להסביר את המושג בפשטותו.

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

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

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

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

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

3. הפקד נבנה ב-CPP והוא לא יעיל.
זה מוכיח שקוד CPP לא יעיל.

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

5. ראיתי חלוקה מרתקת:
*שפת מכונה
*שפת סף - ASM
*שפות ביניים - C/CPP
*שפות עיליות - VB, Fortran
אני מניח ש-QB ו-TP יעמדו בין שפות ביניים לשפות עיליות.

ההבדל בין CPP ל-VB כה רב(כמו שילוב קוד ASM) עד שא"א לשים אותן באותה קטגוריה.

מבחינתי חוזק הוא עד כמה שפה מסויימת מתאימה למשימה מסויימת
שפה יכולה להיות חזקה מבחינה א 'וחלשה מבחינה ב'

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

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

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

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

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

*אין שום קשר בין CPP לידיות.
עד שלא תוכיח שיש קשר כזה הוא לא קיים.

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

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

*לדוגמא:
ישנן פונקציות API שאחד הפרמטרים שלהן הוא ידית לפונקציה.
זה נקרא, אם לא ידעת מנגנון CallBack Function.
כדי להשיג את הידית(שבמקרה הנ"ל היא מצביע, LPVOID עד כמה שאני זוכר) משתמשים באופרטור AddressOf על הפוקנציה שזקוקים לידית עליה, מכניסים את התוצאה למשתנה מסוג LONG, ושולחים ל-API.

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

*ב-VB אין MAIN.
בקובול אין MAIN.
ב-ASM אין MAIN.
בפורטרן אין MAIN.
בלוגו אין MAIN.
על מה אתה מדבר?

בוא נניח שהתכוונת ל-C.
לטענתך "כתובת התכנית" היא הכתובת של נקודת הכניסה שלה?
הנה מחשב תיאורטי שבו הנתונים של התכנית נשמרים לפני קוד התכנית(DS קטן מ-CS, וזה בהנחה שאני עובד עם Segmented Addresses, אבל רציתי להשתמש במונחים מוכרים, כדי לא לבלבל אותך).
אז הכתובת לתכנית היא לפני הכתובת לנקדות הכניסה!

*נכון. פקדי ActiveX אכן עושים שימוש נרחב בידיות.
אבל מה זה מוכיח ואיך זה קשור אלינו?

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

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

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

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

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

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

ג) אני אחזור על עצמי שוב. חפש ב-Google, יש המון מאמרים על זה, ואני בטוח שתמצא את הפיתרון הרצוי.

ד) טוב שהבנתי את כוונתי.

ה) נתחיל בזה שאני לא, ואין שום סיבה שבעולם לכך שתבטא את העצבנות שלך כאן. גם אני אלך אחד אחד.
* לפי מה שכתבת בהמשך, אתה באמת לא יודע מה זה Handle. אל תלך למילון עברי-אנגלי ותפרש לי מה זה Handle, כי זו לא המשמעות הנכונה מבחינת התיכנות.
פלטרפומת ה-Win32, בנוייה כמערכת קלינט/שרת, כאשר הקלינט הוא התוכנה, והשרת הוא ה-Windows עצמו. מערכת השרת, נועדה לטפל ולנהל את התוכניות, ולספק להן את המידע הדרוש בזמן המתאים. למשל, כשבתוכנית כלשהי נלחץ כפתור מסויים, השרת מספק את המידע לאותה תוכנית, כי נלחץ אצלה כפתור. עכשיו, איך השרת יכול להעביר לתכנית את המידע הזה ? בשביל זה יש Handleים. בתחילת התכנית, מוצהרת הגדרה אשר מסבה פונקציה כלשהי להיות Handle של התכנית, ואז נרשם המידע הנחוץ בשרת (כתובת ה-Handle, טפסים, כותרות וכו'). כשילחץ הכפתור, השרת ידע לספק את המידע הנחוץ לכתובת של ה-Handle, כלומר הוא יהיה גוף חיצוני לתכנית שישתמש בפונקציה שהוגדרה להיות Handle.
אותה פונקציה, מקבלת כפרמטרים את המידע הרלוונטי, ומסבה אותו למידע "קריא", כמו הודעה. כעת, היא יודעת כי המידע מורה על כפתור מסויים שנלחץ, והיא תקרא לפונקציה של הכפתור.
זה בגדול ה-Handleים, ה"פשוטים" שחייבים להיות בכל תכנית חלונאית, תחת Win32.
מנגנון ה-CallBack Function הוא אותו מנגנון של השרת. כשאתה מעביר Handle לפונקציה שכזו, היא מחזירה ערכים בדיוק כמו שהשרת עושה. כך למשל פועלים הפקדים של ה-VB, שהרי נבנו ב- ++C. הם מקבלים מידע אודות המתרחש סביבם בכל הנוגע אליהם, ומבצעים פעולות.
בכל מקרה, ה-Handle עצמו, צריך וחייב להיות פונקציה שהערך המוחזר ממנה יהיה מסוג פוינטר (לרוב *void), זאת לשם ביצוע הפעולות הנדרשות שממומשות ב-CallBack Function.
בקשר לפונקציות API שדיברת עליהן. נו הרי בוודאי שהן CallBack Function, כי הן חלק מהמערכת של השרת, ולכן המנגנון שלהן משותף למנגנון הכללי של השרת.

* עכשיו, בקשר לקשר ל- ++C.
תגיד לי, או תן לי דוגמה אחת, ורק אחת, על כך שמתכנת VB (לא ++C/C וכו') היה יודע את הנ"ל, והרי הנ"ל הוא מה שקורה בפועל, בלי קשר ל- ++C/C. הרי ב-VB אין לך פונקצית Handle כלשהי שאחראית על הטיפול ב"שיגרות" או "אירועים" וכו'. הכל "אוטומטי", ולכן מתכנת VB לא מודע למה שקורה בפועל.
ב- ++C/C, לעומת זאת, חייבים להגדיר פונקצית Handle, כחלק מההצהרות הנחוצות לשם יצירת חלון ורשימתו ב"שרת".
לכן, אם היית באמת מתכנת ב- ++C (ואני מדבר על פיתוח מערכות חלוניות), היית חייב להיתקל במושג.

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

* אכן ב-VB ה-Handle הוא אוטומטי, ולא ממומש על ידי המתכנת, כמצויין לעיל.

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

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

* כנ"ל.

* פקד אכן עובד עם Handlים, ונדמה לי שציינתי את זה למעלה.

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

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

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

****************

עכשיו, ל-תגובהRe:
3. אני לא מבין למה אתה מתקשה להבין. אמנם הפקד אינו יעיל, אבל הוא נבנה ב- ++C. בדוגמה שהבאתי (++Microsoft Visual C), הפקד לא יעיל למטרה שלו, מפני שכדי לגרום לפקד ה-Rich Text Box לעבוד בצורה מהירה, כדי שהקוד יהיה כמו הפקד של ++MVC, צריך לשנות את הפקד עצמו. אני ניסיתי לגרום לו לעבוד כמו הפקד המקורי ע"י פונקציות ושיגרות ב-VB בלבד... וזה לא הלך (היה איטי, ולא יעיל), ולכן, צריך לכתוב את הפקד עצמו.
עצם העובדה שהפקדים בנויים ב- ++C, מוכיח את תלות VB ב- ++C, שזוהי כבר חולשה עצומה.

5. VB מתאימה בהחלט למשימה וליעוד שלה (ממשק-משתמש), אם כי גם פה נתקלים בבעיות שב- ++C היו הרבה יותר פשוטות. היא נוחה ופשוטה כל-כך, עד שב-0 שורות קוד, ניתן ליצור חלון עם 1000 כפתורים, תיבות טקסט, ומה שבא ליד.
בוא נסכם ש- ++C היא שפה יותר מעמיקה.

6. ברור שב- ++C יש אלמנטים פרוצדוראליים, ולכן עדיף ללמוד שפה פרוצדוראלית לפני... הרי הבסיס, כמו שהמעבד עובד, הוא כתיבה לינארית (כמו גם פרוצדוראלית).
בכל מקרה, גם התוכנה הכי פשוטה ב- ++C, כמו לכתוב למסך "Hello World" תיעשה באמצעות תיכנות OO, בגלל השימוש באובייקטים ה-Input וה-Output (ובהיררכייה שלהם), וזה ללא ספק OOP, ולא פרוצדוראלי, ככה שאתה משאיר אותי בספק.
בכל מקרה, אם ידעת לפני זה שפות כמו Pascal וכו', אז זה די בסדר.

3. נכון VB תלויה ברכיבים חיצוניים(בלי להכנס לשפה שבהם הם נכתוב, כי הם יכלו להכתב בכל שפה ולאו דווקא CPP).
אני לא מחשיב את זה כחולשה.

הבאתי את ההגדרה של "חוזק" של שפה לדעתי.
http://rotter.net/nor/prog/5489.shtml#29
2 שורות צבעוניות.
חוזק של שפה נמדד בעד כמה היא מתאימה למשימה מסויימת.
VB חזקה ביצירת ממשקי מתשמ עזירים לווינדוס, וחלשה בגישה ישירה לחומרה, עבודה על OSות אחרות, וכו'...
חזקה מבחינה אחת, חלשה מבחינה אחרת.

5. מבחינת ממשק משמתמש גרפי לווינדוס אין על VB.

6. התחלתי מ-QB לפני שנים רבות, כשהיא לא סיפקה את צרכי עברתי ל-CPP, למדתי את הבסיס של CPP(קרי C) קודם, אבל לא התעכבתי עליו יותר מהנדרש.
מאז כבר שכחתי שקיימים PRINTFים...:-)

* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *

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

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

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

ד) למען האמת לא הבנתי אותך.

* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *

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

*אם הייתי מתכנת CPP לווינדוס הייתי נתקל במושג.
אבל אולי אני מתכנת C ל-RT שעובד ב-VxWorks וכותב את הקוד של Linux?

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

*לא אמרתי שאמרת שמתכנת VB הוא עלוב.
אמרתי שאתה מזלזל ב-VB.
האם זה לא נכון?

*ב-VB לא מגדירים CallBack Functions כדי להשתמש ב-API.
(כי לא משתמשים ב-API).

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

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

*לא הבנתי מה אמרת?
האם אפשר לבנות ב-CPP צבע?
אפשר לבנות ב-CPP צורה?
אפשר לבנות ב-CPP ריח(לא ריח מסויים, אלא את הריח עצמו)?
באותה מידה א"א לבנות ב-CPP ידיות.

* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *

עכשיו הנה דוגמא ל-HANDLEים שלא קשורה כלל לווינדוס או ל-C.
ישנו UNIT ל-TP7 שכתבתי ע"מ ליצור מערכים דינמיים.
הפונקציה CreatArray מחזירה handle למערך.
והפונ' GetElement, SetElement, DestroyArray מקבלות בפרמטר, בין השאר, את אותו ה-handle.

אני ממש לא מבין איך אתה יכול לא-להחשיב תלות של שפה אחת בשפה שנייה כחולשה. אם זו לא הייתה תלות, אלא יכולת שיתוף, אז זה משהו אחר לחלוטין, אך כשמדובר בתלות...זוהי בהחלט חולשה.

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

בקשר ל-Handleים... ברור שהם לא קיימים פיסית !!! בדיוק כמו שפונקציות לא קיימות פיסית... על מה בכלל הוויכוח פה ???
אני יתן לך עוד דוגמה של Handle:
לפני כמה ימים, הייתה בארץ תחרות "רובונר 2003"... תחרות שבה התחרו בערך כ-50 רובוטים, כשהמטרה היא לחפש בדירה (2.5 על 2.5 מ') בעלת 4 חדרים נר, ולכבות אותו בזמן הקצר ביותר וכו'... אני תיכנתתי את הרובוט שזכה במקום השני (אגב, היה צריך להיות ראשון, אם לא הייתה שחיתות), ובתיכנות שלו, בגלל חוסר אמצעים, היה עלי לשלב בין שני בקרים (מחשבים קטנים) של לגו, שיש להם יכולת שידור וקליטה של IR, כלומר היה עלי להעביר ביניהם מסרים, באמצעות IR.
עכשיו... איך הבקר יודע שהגיעה אליו הודעת IR מהבקר השני ? באמצעות Handle שהגדרתי, וכו' וכו'...
בקיצור, אני מקווה שהבנת את הכוונה שלי, גם כשזה לא נוגע ל-Win32.

בנוגע להחזרת מיקום בזיכרון מתוך התוכנית... זה בדיוק מה שקורה במנגנון ה-CallBack Function.

אז בוא נעשה מה שהצעתי מזמן.

ההבדל בין הדיעה שלי לדיעה שלך הוא מה נחשב שמדד לחוזק של שפה.

בברכה...

נ.ב.
כפל:
כפל של מספרים שלמים מיושים ע"י 32 אוגרים בלי 32 ביט.
לדוגמא, אשתמש ב-4 ביט כדי לקצר:
1001
X
1101
____
1101 אוגר
0000 אוגר
0000 אוגר
1101 אוגר
____
1110101

יצא לי: 9*13=117

נ.ב: זה פשוט כמו כפל ארוך... ככה שיש בזה שילוב של אלמנט חיבור...

כשהתגובות שלך מתקצרות - שלי מתקצרות בהתאם.

הייתי לי טעות, אני כתב מחדש:

01100100        100
X               X
01100100        100   
_____ ___
00000000        100
 01100100        000
  01100100        000
   00000000
    00000000
     01100100
      00000000
       00000000
_____ ___
010011100010000 10000
neat, eh?
but not so similiar to:
iRes = iVarA * iVarB;

ועדיין לא הבנתי למה VB חלשה מ-CPP...

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

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

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

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

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

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

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

אל תבואו בהצהרות שיותר קל לתכנת ב-VB, בגלל שאתם לא יודעים כמה התוכנה "מפסידה" כשהתחביר הוא לא של ++C/C.
לכן, לדעתי, Microsoft באה עם הגרסה המשופרת VS .Net, כדי לאפשר פחות או יותר שילוב של הדברים.

בכל מקרה, כפי שנאמר פה כבר מקודם, VB מתאימה יותר לפיתוח ממשקים וויז'ואלים כממשקי משתמש, אבל לתיכנות אמיתי, מהות התוכנה, ואיך המחשב עובד, מתאים בהחלט להשתמש ב- ++C/C.

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

אתה צריך להזהר במה שאתה אומר.
ה"שילוב בין השפות" הוא לא תכונה של סבביבת העבודה VisualStudio .NET, אלא תכונה של המהדרים וה-framework.

כמו שאמרו הרבה פעמים, אנשים גדולים ממך וממני.
התחביר לא משנה.
האם בגלל שב-C יש }{ ובפסקל יש BEGINים ו-ENDים פסקל חזקה מ-C או להיפך?
שטויות!

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

כמה התוכנית מפסידה בגלל שהתחביר הו לא של C/CPP?
אתה נשמע כאילו אתה יודע.
אולי תספר לנו?

עכשיו הגענו לנקודה.
אתה חצוף!
איך אתה מעז לומר ש"אנשים, התבלבלתם בין סביבת פיתוח, לבין שפה".
כאשר אתה בעצמך לא מבחין בין סבביבת פיתוח למהדר?
"ראיתי שדיברו פה על VS.Net שזה בכלל סטה מן הנושא. אז נכון, אפשר לשלב בסביבה זו בין השפות וכו'," - אתה לא מבחין בין סביבית פיתוח למהדר.
"אל תבואו בהצהרות שיותר קל לתכנת ב-VB, בגלל שאתם לא יודעים כמה התוכנה "מפסידה" כשהתחביר הוא לא של ++C/C.
לכן, לדעתי, Microsoft באה עם הגרסה המשופרת VS .Net, כדי לאפשר פחות או יותר שילוב של הדברים." - והנה שוב אתה לא מבחין בין סביבת פיתוח לשפה.
איזו שכות מוסרית יש לך להגיד ש"הם" לא עושים כך וכך כאשר אתה עמצך לא עושה זאת?
חצוף, כבר אמרתי?