תאר לך מצב כזה:

#include <stdio.h>
.
typedef enum {false = 0, true = 1} bool;
.
bool swap(int *a, int *b)
{
   int temp = *a;
.
   *a = *b;
   *b = temp;
.
   return true;
}
.
int main()
{
   bool i;
   int x = 4, y = 5;
.
   if(i = swap(&x, &y))
      printf("Succeeded");
   else
      printf("Failed");
.
   return 0;
}

חוץ מזה בVB התנאי היה יותר פשוט

if swap(a,b) then

אני מסכים איתך בכל מה שאמרת מלבד דבר קטן.

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

אני אישית דווקא אוהב את זה שב-BASIC ונגזרותיה יש אפרטור אחד, כי זה תואם את דרך המחשבה שלי:-)

1. איזה הגדרת טיפוסים יש בפסקל?

2. QB מספיק יעילה ללימוד, שהיר על זה אנחנו מדברים!
לא דיברתי על כתיבת מערכות RT או DSP ב-QB, נכון?
עניין היעילות לא קשור!

3. אני מעדיף את CPP" ומעולם לא למדתי C ברצינות, ושם יש צורך ב-Casting.

4. C שפה מלאת בגים, אתה מחדש משהוא?

5. בפסקל אין RANGE CHECKING.

6. ב-CPP יש Reference Variables.
מצביעים בפסקל חסרי תועלת.

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

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

9. אני ממליץ להתחיל מ-QB.
אם מדובר באדם מבוגר(15/16+) שרוצה ללמוד תכנות ברצינות ולא כדי "לעשות ווינדוס", או כדי "לעשות DOOM3", הייתי ממליץ על CPP.
לא C.

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

תחביר זה משהוא שמתרגלים אליו מאוד מהר: כשעברתי מQB לפסקל
אני התחרפנתי לגמריי מהתחביר, היה נראה לי קטנוני למדיי הצורך
לשים ; בסוף כל שורה, מהר מאוד זה נעלם ואני שם ; מבלי להשקיע
בכך שניה מחשבה, כשעברתי לc שוב התחביר עצבן אותי, מה פתאום
צריך לשים סוגריים מסביב לתנאי של if ? אבל גם לזה התרגלתי ללא
קושי רב. ובצורה דומה התרגלתי לכתוב גם LISP עם סוגריים לפני
השם של הפונקציה ואריטמטיקה בprefix notation והתרגלתי גם
לsmall talk שם התחביר בכלל מעוות. תחביר זה עניין שולי לחלוטין,
ועם התחביר של פסקל זה מה שמציק לך אני חושב שזה רק משום שאתה
לא רגיל אליו.

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

אם זה כ"כ טריוויאלי לא תהיה לך בעיה.
נכון?

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

למעשה בהודעה זאת, אתה אומר שאתה ממליץ להתחיל מC++ ולא מC, וזה כבר עניין
אחר, שכן בניגוד לדעה הרווחת C וC++ הם שני שפות מאוד מאוד שונות,
הSYNTAX מאוד דומה, אבל התחביר שונה והגישה בכלל אחרת.

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

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

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

לצורך הבהרה אני עובד עם C ועם C++ הרבה ומאוד מרוצה משניהם, בעבר
כתבתי הרבה מאוד קוד גם בפסקל, ולפני כן בQB, כולם שפות יפות מאוד,
לכולם יתרונות וחסרונות ואילו בסופו של עניין כששואלים עם איזו שפה
להתחיל התשובה שלי תלויה בגיל לילדים: QB, לתלמידי חטיבה PASCAL
לתיכוניסטים והלאה PASCAL או C בשום אופן לא C++ או JAVA

1. לא ענית על אף-אחת מטענותי.

2. בטורבו פסקל 7 שבו אני עובד, Range Checking מכובה כברירת מחדל, כך נדמה לי.
בכל-אופן, אני תמיד נוהג להפעיל את ה-Compiler Directice של Range Checking לבד.
אבל גם ב-QB יש.

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

4. אתה מעוות את מה שאמרתי.
לא הצעתי ללמוד OOP, הצעתי ללמוד CPP במקום C.
פשוט, C לא נעימה למתחילים.
בניגוד לפסקל ו-QB שבעלות תחביר יחסית נעים, התחביר של PRINTF פשוט איופ ונורא, זו פונקציה בסיסית.
COUT הרבה יותר נעים.
כמובן(!) שאני ממליץ להתחיל מהבסיס ורק אחרי שיודעים מה עושים ללמוד OOP.
וכן, גם אני ראיתי אנשים שכותבים OOP ויוצא להם קוד איום ונורא.

5. QB עדיף על פסקל להתחלה. (לצעירים יותר)
CPP עדיף על C להתחלה. (למבוגרים יותר)

בברכה...

2) סיכמנו שיש Range Checking בפסקל ואין בC, תודה שאתה מסכים.

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

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

5) בפרוש לא.

1. אני בטוח שלא.

2. אבל ב-QB יש.

3. אתה.
א"א.
אין דרך לקבל דינמית i*k בתים ולגשת אליהם בצורה הגיונית(באופן סביר).

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

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

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

הרבה אנשים חושבים שC++ זה פשוט עדיף על C, ויש שמנסים להתייחס לC++
כאל C משופר, אבל זה לא המצב. ואפילו אם נתעלם ממחלקות ותבניות וכל
מה שתרצה, אנו נגלה שיש הבדלים מהותיים בין C לבין C++. שורת קוד
נאיבית למדיי: a=b=c=d=e;
בC++ עשויה לגרום פתאום להקצאת זכרון סמויה(מה שמשפיע על ביצועים ולעיתים
על התנהגות) C++ מתנהג אחרת, הוא עושה דברים מוזר.

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

*****
העניין השולי:
NEW הרבה יותר נוח מ-MALLOC(ו-ALLOCים למיניהם).
COUT הרבה יותר נוח מ-PRINTF.
CPP יותר נעימה למשתמש המתחיל מאשר C.

תפסיק להתווכח עם עובדות

*****

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

*****

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

*****

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

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

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

DRYICE

אתה טועה?
או משקר??

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

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

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

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

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

6. ושוב אני מזכיר שאני מבקש לינק.
אבל הנה הלינקים שאני מצאתי:
http://rotter.net/nor/prog/5219.shtml#4 - אתה מגיב להודעת השורש.
http://rotter.net/nor/prog/5219.shtml#7 - אני מגיב להודעתך ומציע את CPP בפירוש ולא את C(עיין בסעיפים 3, 6, 7 ו-9).
http://rotter.net/nor/prog/5219.shtml#9 - פה אתה מנסה ללמד אותי מהו OOP, אבל נראה לי שאני יכול ללמד אותך...
http://rotter.net/nor/prog/5219.shtml#11 - ואני מסביר לך שאמרתי C ולא CPP.
ומשם והלאה אתה מבלבל לי את המוח עם שקריך הנלוזים.

בברכה...

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

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

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

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

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

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

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

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

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

אני לא מציע לכתוב CPP רע, אני מציע ללמוד בהתחלה את הבסיס של תכנות, ללא OOP, תוך שימוש ב-CPP, ורק לאחר מכן ללמוד OOP, תוך שימוש ב-CPP/JAVA.

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

בהודעת השורש(פתיחת האשכול) גם הצעתי את CPP ולא את C.

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

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

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

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

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

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

4. זה רע מאוד שלא מבינים ששפת תכנות היא כלי, כלי כדי לתכנת, שלא מבינים שסביבית הפיתוח היא כלי, כלי כדי להגיע לשפת התכנות, שלא מבינים מהו מהדר, שלא מבינים...
אז נכון, אפשר לוות ר על זה בהתחלה, אבל חשוב לא לשכוח את זה.
(כמו השאלה ששאלו פה "איך הופעים קובץ של VB ל-EXE?",
אח"כ אותו אדם שאל "אבל איך אני הופך קובץ FRM לקובץ VBP?",
אותו אדם אפילו לא יודע מהו קובת FRM ומהו קובץ VBP ב-VB...)

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

ולהערות:
מה שניסו להסביר לך, זה שכשאתה לומר C, אתה לומד, במידה מסויימת, איך המחשב עובד, איך נבנית תוכנית, ואיך היא מורצת. לא מדובר על קוד מכונה, אלא על שפה עילית קצת יותר מפורטת.
לכן, כשמקצים זיכרון עבור מצביע מסוג int (למשל), תצטרך להעביר כפרמטר את גודל ההקצאה, כפי שקורה באמת !!! - ;((malloc(pointer, sizeof(pointer
ב- ++C, אתה פשוט כותב new pointer, ולכן אתה לא מבין את המשמעות של ההקצאה.

אותו הדבר לגבי printf.
כשאתה מדפיס למסך, לדוגמה, מספרים ממשיים, מה שקורה בפועל, זה שהם מומרים לתווים (bytes) בהתאם להוראה ("%2.2f").
ב- ++C אתה פשוט כותב cout ומדפיס את הערך.

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

העובדות מדברות בעד עצמן.

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

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