מטריושקה סי. מערכת שפת תוכנית שכבתית

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

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

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

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

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

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

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

הצורך השלישי הוא להבהיר את הרעיון של תוכנית.

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

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

מה שמחזיר אותנו להרצאה הראשונה של Privatdozent Mendeleev. מה להגיד לסטודנטים א'? איפה האמת? זאת השאלה.

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

להלן תקציר הספר.

1. מבוא

בשנת 1969 נוצרה שפת C, שהפכה לשפת התכנות הבסיסית ונשארה כזו במשך 50 שנה. למה זה כל כך? קודם כל, כי C הוא הוחל השפה שנתנה את התוכנית אֶנוֹשִׁי להציג במקום זאת מְכוֹנָה. הישג זה אובטח על ידי שפות ממשפחת C: C++, JavaScript, PHP, Java, C# ואחרות. שנית, זו שפה קצרה ויפה.

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

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

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

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

המערכת נבנית תוך התחשבות קהילות של שפות יישומיות, הנובעים מכפיפות הדיבור שלהם. סט אחד של יחידות Matryoshka C מאפשר לך לתאר ולהשוות שפות שונות, ליצור סדרה של Matryoshkas: C++, PHP, JavaScript, C#, MySQL, Python וכן הלאה. ראוי ונכון ששפות שונות מתוארות לפי יחידות של השפה הבסיסית.

2. פרק 1. מודל דיבור של התוכנית. נקה ג

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

1. דיבור - דיבור ישיר של המתכנת הפותר את הבעיה,
2. מקודד - קידוד פתרון לצורה מתמטית בשפת C (או בכל שפה אחרת)
3. ופקודה - פקודות מכונה ישירות.

מודל הדיבור מסביר מדוע C היא שפה פשוטה ומובנת. שי בנוי בדמותו ובדמותו של הדיבור האנושי המוכר לנו.

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

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

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

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

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

השתקפות מתבצעת על ידי שני סוגי ביטויים:

1. חישוב (HF) - משקף שינוי בתכונות של אובייקט. התכונה של חפץ מתבטאת במספר, ואז פעולה על תכונה היא פעולה על מספר - פעולה.
2. כְּפִיפוּת (Pch) - משקף שינוי בסדר הפעולות. אב הטיפוס של Pch הוא משפט מורכב של דיבור, לכן רוב סוגי ה-Pch מתחילים בצירופים כפופים "אם", "אחרת", "בזמן", "עבור". סוגים אחרים של מחשבים משלימים אותם.

אגב, האם אתה מאמין שבתיאור C אין שם לביטויי חישוב - הם נקראים פשוט "ביטויים"? לאחר מכן, כבר לא יתפלא שאין שם ושיוך לסוג הכפיפות, ואכן מיעוט השמות, ההגדרות וההכללות בכלל. הסיבה לכך היא שה-K/R המפורסם ("The C Language", Kernighan/Ritchie, 1978) אינו תיאור, אלא מדריך לשימוש בשפה.

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

3. פרק 2. מערכת שכבות. קצר ג

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

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

במצגת כזו לא קל להבין מי עמד על מי.

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

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

יחידות השפה מחולקות ל-6 רמות:

1. יחידות - שורות טבלה
2. מחלקות - קבוצות מיוחדות של סוגים (חלקים מהשורה הראשונה)
3. סוג - תאים (רמת החלוקה העיקרית)
4. מיני-על - מפרידי מינים (רמה נדירה)
5. סוגים - נוסחאות יחידות בתחתית התא או בנפרד
6. דפוסים - היחידות עצמן (למילים בלבד)

מילים לדוגמה מתארות מילון - תת-מערכת נפרדת המורכבת מאותן שש רמות.

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

4. הפרקים הבאים. סי נאה

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

מה בדיוק הציע שי? תמונה ושכבה.

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

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

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

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

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

תמונה

תמונה הוא שם קדם-פיגורטיבי של כמות, המגדיר 1) את התכונות הפנימיות של הכמות ו-2) את בחירת הפעולות לכמות.

המילה "סוג" (סוג) תואמת לחלק הראשון של ההגדרה: "תכונות פנימיות של כמות". אבל המשמעות העיקרית של התמונה היא בחלק השני: "בחירת פעולות לכמויות".

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

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

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

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

הגדרה ברורה של תמונת המושג מאפשרת לנו בהחלט לדבר על שני מושגים נוספים: ערך и המבצע.

גודל ותפעול

ערך - המספר בעיבוד.

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

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

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

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

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

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

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

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

נותרו מספר פעולות רַבִּיםו - יחיד. פעולות כאלה מוגדרות רק עבור סוג אחד של ארגומנטים: שארית חלוקה - ארגומנטים שלמים, ערימה (פעולות סיביות) - מספרים שלמים טבעיים. Ma3 מציין את ריבוי הפעולות עם סימנים (#^) המציינים את התמונות שעבורן מוגדרת הפעולה. זהו נכס חשוב אך התעלמו ממנו בעבר של כל פעולה.

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

סִיוּעַ

סִיוּעַ - פעולה הנלווית למבצע.

אם ניקח בחשבון את הפעולה כפעולה העיקרית, אזי נוכל להבחין בין שני נלווים המספקים את הפעולה ונבדלים ממנה. אלו הם 1) שליטה במשתנה ו-2) כפיפות. פעולה זו נקראת סִיוּעַ.

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

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

שקול את הפעולות הנלוות, או סִיוּעַ.

שליטה משתנה

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

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

כְּפִיפוּת

כְּפִיפוּת - חבר/השבת קטעי שכבה.

שפת C הציעה שיטה יישומית לשליטה בסדר הפעולות, שונה מ-Assembler – כפיפות. הוא משקף ומפתח משפט מורכב בדיבור עם חלוקה ברורה לחלק הראשי (סעיף כפיפות) ולחלק הכפיף (סעיפים תת-רמה/תת שגרה).

גם ההכרזה וגם ההגשה בנויים לחלוטין על הרעיון שִׁכבָה.

שכבה

שכבה הוא קבוצה סלקטיבית ברמה אחת מוגבלת של ביטויים.

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

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

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

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

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

חֲרִיגָה

חֲרִיגָה - שינוי המאפיינים הרגילים של השם החדש.

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

5. הפרק האחרון. משותף של שפות יישומיות

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

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

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

עומס יתר ופולימורפיזם

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

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

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

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

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

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

מילים רוסיות מחליטות.

מסלול המראה

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

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

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

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

שפת MySQL ראויה לציון מיוחד. נראה שאין שום דבר במשותף, אבל הוא מתואר בצורה מושלמת על ידי מטריושקה, וההיכרות איתו נעשית מהירה וקלה יותר. מה שחשוב, בהתחשב בחשיבותו לרשת - דרך האוכל של התכנות המודרנית. ובמקום שיש MySQL, יש SQLs אחרים. ובכן, כל מיני Fortran-Pascal-Pythons מתוארים גם על ידי מטריושקה, ברגע שהם שמים עליהם את היד.

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

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

מקור: www.habr.com