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

ספריה טכנית בחינם

הערות הרצאה, דפי רמאות
ספרייה חינם / מדריך / הערות הרצאה, דפי רמאות

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

הערות הרצאה, דפי רמאות

מדריך / הערות הרצאה, דפי רמאות

הערות למאמר

תוכן העניינים

1. מדעי המחשב. מֵידָע

ייצוג ועיבוד/מידע. מערכות מספרים

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

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

1) הצגה רשמית של צורות מידע חיצוניות;

2) משמעות מופשטת של מידע, תוכנו הפנימי, סמנטיקה;

3) יחס של מידע לעולם האמיתי.

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

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

y = f(x,t)

איפה הזמן,

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

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

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

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

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

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

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

2. ייצוג מספרים במחשב. מושג פורמלי של אלגוריתם

מעבדי 32 סיביות יכולים לעבוד עם עד 232-1 זיכרון RAM, וניתן לכתוב כתובות בטווח 00000000 - FFFFFFFF. עם זאת, במצב אמיתי, המעבד פועל עם זיכרון של עד 220-1, והכתובות נופלות בטווח 00000 - FFFFF. ניתן לשלב בייטים של זיכרון לשדות באורך קבוע ומשתנה כאחד. מילה היא שדה באורך קבוע המורכב מ-2 בתים, מילה כפולה היא שדה של 4 בתים. כתובות שדות יכולות להיות זוגיות או אי-זוגיות, כאשר כתובות זוגיות מבצעות פעולות מהר יותר.

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

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

x = 10n - \x\, כאשר n הוא עומק הסיביות של המספר.

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

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

מושג פורמלי של אלגוריתם

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

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

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

הפונקציות הבסיסיות והאלגוריתמים הנלווים להן יכולות להיות:

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

2) פונקציית הזהות של n משתנים בלתי תלויים בצורת Ψ ni. לאחר מכן, אם הסימן של הפונקציה הוא Ψ ni, אז יש לקחת את הערך של הפונקציה כערך של הארגומנט i-th, בספירה משמאל לימין;

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

3. מבוא לשפת פסקל

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

1) 26 אותיות קטנות לטיניות ו-26 אותיות לטיניות גדולות:

2) _ (קו תחתון);

3) 10 ספרות: 0 1 2 3 4 5 6 7 8 9;

4) סימני פעולה:

+ - O / = <> < > <= >= := @;

5) תוחמים:., ( ) [ ] (..) { } (* *).. : ;

6) מפרטים: ^ # $;

7) מילות שירות (שמורות): ABSOLUTE, ASSEMBLER, AND, ARRAY, ASM, BEGIN, CASE, CONST, CONSTRUCTOR, DESTRUCTOR, DIV, DO, DOWNTO, ELSE, END, EXPORT, EXTERNAL, FAR, FILE, FOR, FORWARD, FUNCTION, GOTO, IF, IMPLEMENTATION, IN, INDEX, HERITED, INLINE, INTERFACE, InterRUPT, LABEL, LIBRARY, MOD, Name, NIL, NEAR, NOT, OBJECT, OF, OR, Packed, PRIVATE, PROCEDURE,

תוכנית, פומבי, הקלט, חוזר, תושב, קבע,

SHL, SHR, STRING, THEN, TO, TYPE, UNIT, TILL, USES,

VAR, VIRTUAL, WHILE, WITH, XOR.

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

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

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

2) ניתן לקבוע את סוג הערך שניתן על ידי קבוע, משתנה או ביטוי על פי צורתם או תיאורם;

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

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

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

לפסקל יש את עדיפות האופרטור הבאה:

1) חישובים בסוגריים;

2) חישוב ערכי פונקציה;

3) פעולות לא דומות;

4) פעולות * / div mod ו;

5) פעולות + - או xor;

6) פעולות יחס = <> < > <= >=.

4. נהלים ופונקציות סטנדרטיות

פונקציות אריתמטיות

1.Function Abs(X); מחזירה את הערך המוחלט של הפרמטר.

2. פונקציה ArcTan(X: Extended): Extended; מחזירה את טנגנס הקשת של הארגומנט.

3. פונקציה Exp(X: Real): Real; מחזיר את המעריך.

4.Frac(X: Real): אמיתי; מחזירה את החלק השברי של הארגומנט.

5. פונקציה Int(X: Real): Real; מחזירה את החלק השלם של הארגומנט.

6. פונקציה Ln(X: Real): Real; מחזירה את הלוגריתם הטבעי (Ln e = 1) של ביטוי מסוג אמיתי x.

7. Function Pi: מורחב; מחזירה את הערך Pi, המוגדר כ-3.1415926535.

8.Function Sin(X: Extended): Extended; מחזירה את הסינוס של הטיעון.

9.Function Sqr(X: Extended): Extended; מחזירה את הריבוע של הטיעון.

10.Function Sqrt(X: Extended): Extended; מחזירה את השורש הריבועי של הארגומנט.

נהלים ופונקציות של המרת ערך

1. הליך Str(X [: Width [: Decimals]]; var S); ממירה את המספר X לייצוג מחרוזת.

2. פונקציה Chr(X: Byte): Char; מחזירה את התו עם מספר האינדקס x בטבלת ASCII.

3. פונקציה גבוהה (X); מחזירה את הערך הגדול ביותר בטווח של הפרמטר.

4.FunctionLow(X); מחזירה את הערך הקטן ביותר בטווח של הפרמטר.

5.פונקציה Ord(X): LongInt; מחזירה את הערך הסידורי של ביטוי מסוג ממוספר.

6. Function Round(X: Extended): LongInt; מעגל ערך אמיתי למספר שלם.

7. פונקציה Trunc(X: Extended): LongInt; חותך ערך סוג אמיתי למספר שלם.

8. נוהל Val(S; var V; var Code: שלם); ממיר מספר מערך מחרוזת S לייצוג מספרי V.

נהלים ופונקציות של ערך רגיל

1. הליך Dec(var X [; N: LongInt]); גורע אחד או N מהמשתנה X.

2. Procedure Inc(var X [; N: LongInt]); מוסיף אחד או N למשתנה X.

3. פונקציה מוזרה(X: LongInt): בוליאנית; מחזירה True אם X הוא מספר אי-זוגי, False אחרת.

4.FunctionPred(X); מחזירה את הערך הקודם של הפרמטר.

5 פונקציה Succ(X); מחזירה את ערך הפרמטר הבא.

5. אופרטורי שפת פסקל

מפעיל מותנה

הפורמט של הצהרה מותנית מלאה מוגדר כדלקמן:

אם B אז S1 אחרת S2

כאשר B הוא תנאי מסתעף (קבלת החלטות), ביטוי לוגי או יחס; S1, S2 - הצהרת הפעלה אחת, פשוטה או מורכבת.

בעת ביצוע משפט מותנה, תחילה מעריכים את הביטוי B, ואז מנתחים את התוצאה שלו: אם B נכון, אז מבוצעת המשפט S1 - הענף של אז, והמשפט S2 מדלגים; אם B הוא שקר, אז משפט S2 - הענף else מבוצע, ומשפט S1 מדלגים.

בחר הצהרה

מבנה המפעיל הוא כדלקמן:

מקרים של

c1: הוראה1;

c2: הוראה2;

...

cn: instructionN;

הוראה אחרת

הסוף;

כאשר S הוא ביטוי מסוג רגיל שהערך שלו מחושב;

c1, c2,..., on - קבועים מסוג סידורי איתם מושווים ביטויים S; instructionl,..., instructionN - אופרטורים אשר מבוצע זה שהקבוע שלו תואם את ערכו של הביטוי S;

instruction - אופרטור שמתבצע אם הערך של הביטוי S אינו תואם לאף אחד מהקבועים c1, o2, on.

משפט לולאה עם פרמטר

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

הצהרת לולאה עם תנאי מוקדם

בעוד ב' לעשות ס;

כאשר B הוא תנאי לוגי, אשר אמיתותו נבדקת (זהו תנאי לסיום הלולאה)$;

S - גוף לולאה - משפט אחד. הביטוי השולט על החזרה על משפט חייב להיות מסוג Boolean. הוא מוערך לפני ביצוע ההצהרה הפנימית. ההצהרה הפנימית מבוצעת שוב ושוב כל עוד הביטוי מוערך ל- Trie. אם הביטוי מוערך ל-False מההתחלה, אזי ההצהרה הכלולה במשפט לולאת תנאי מוקדם לא מבוצעת.

הצהרת לולאה עם postcondition

חזור על S עד B;

כאשר B הוא תנאי לוגי, אשר אמיתותו נבדקת (זהו תנאי לסיום הלולאה);

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

6. הרעיון של אלגוריתם עזר

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

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

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

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

1) פרמטרים-משתנים;

2) פרמטרים קבועים;

3) פרמטרים-ערכים;

4) פרמטרי פרוצדורה ופרמטרים של פונקציות, כלומר פרמטרים מסוג פרוצדורלי;

5) פרמטרים משתנים ללא הקלדה.

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

העברת שמות פרוצדורות ופונקציות כפרמטרים

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

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

סוג

Proc = פרוצדורה;

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

7. נהלים ופונקציות בפסקל

נהלים בפסקל

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

נוהל <name> [(<רשימת פרמטרים פורמליים>)];

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

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

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

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

פונקציות בפסקל

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

פונקציה <שם> [(<רשימת פרמטרים פורמליים>)]: <סוג החזר>;

ביישום Borland של Turbo Pascal 7.0, ערך ההחזרה של פונקציה לא יכול להיות מסוג מורכב. ושפת ה-Object Pascal המשמשת בסביבות הפיתוח המשולבות Borland Delphi מאפשרת כל סוג של תוצאת החזרה, למעט סוג הקובץ.

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

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

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

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

8. העברת תיאורים וחיבור של תתי שגרות. הוֹרָאָה

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

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

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

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

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

לדוגמה:

1) {$E+} - חיקוי מעבד מתמטי;

2) {$F+} - יוצרים את הסוג הרחוק של פרוצדורות ופונקציות קריאה;

3) {$N+} - השתמש במעבד שותף מתמטי;

4) {$R+} - בדוק אם הטווחים מחוץ לתחום.

מתגי קומפילציה מסוימים עשויים להכיל פרמטר, לדוגמה:

{$I file name} - כלול את הקובץ בעל השם בטקסט של התוכנית הקומפילית

9. פרמטרים של תוכנית משנה

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

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

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

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

3. קבוצת פרמטרים שלפניה מילת המפתח var ואחריה סוג היא רשימה של פרמטרים משתנים.

פרמטרים של ערך

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

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

פרמטרים קבועים

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

פרמטרים משתנים

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

משתנים פרוצדורליים

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

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

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

10. סוגי פרמטרים של תת שגרה

פרמטרים של ערך

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

פרמטרים קבועים

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

פרמטרים משתנים

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

פרמטרים לא מוקלדים

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

משתנים פרוצדורליים

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

הנוהל או הפונקציה בהקצאה חייבים להיות:

1) לא סטנדרטי;

2) לא מקונן;

3) לא הליך מסוג inline;

4) לא על ידי הליך ההפסקה.

פרמטרים של סוג פרוצדורלי

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

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

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

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

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

נהלים ופונקציות עבור משתנים מסוג מחרוזת

1. עותק פונקציה(S: מחרוזת; אינדקס, ספירה: מספר שלם): מחרוזת;

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

2. הליך מחיקה (var S: מחרוזת; אינדקס, ספירה: מספר שלם);

מסיר מחרוזת משנה של תווים באורך Count מהמחרוזת S, החל ממיקום אינדקס. S הוא משתנה מסוג String. אינדקס וספירה הם ביטויים מסוג מספר שלם. אם אינדקס גדול מאורך S, לא יוסרו תווים.

3. Procedure Insert(מקור: String; var S: String; אינדקס: שלם); משרשרת תת-מחרוזת למחרוזת, מתחילה במיקום מוגדר. מקור הוא ביטוי מסוג String. S הוא משתנה מסוג String בכל אורך. אינדקס הוא ביטוי מסוג מספר שלם. הוספה מכניסה את המקור ל-S, מתחילה בעמדה S.

4. אורך הפונקציה (S: מחרוזת): מספר שלם;

מחזירה את מספר התווים המשמשים בפועל במחרוזת S. שימו לב שכאשר משתמשים במחרוזות עם סיומת Null, מספר התווים אינו שווה בהכרח למספר הבתים.

5. פונקציה Pos(Substr: String; S: String): מספר שלם; מחפש תת-מחרוזת במחרוזת. Pos מחפש Substr בתוך S

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

12. הקלטות

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

תיאור רשומה בשפת פסקל מתבצע באמצעות מילת השירות RECORD ולאחריה תיאור מרכיבי הרשומה. תיאור הערך מסתיים במילת השירות END.

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

הקלד שורה = שיא

FIO: מחרוזת[20];

טל: מחרוזת[7];

הסוף;

var str: שורה;

תיאורי רשומות אפשריים גם ללא שימוש בשם הסוג, לדוגמה:

var str: שיא

FIO: מחרוזת[20];

טל: מחרוזת[7];

הסוף;

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

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

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

13. סטים

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

סוג מרובה מתואר באמצעות קבוצת מילות הפונקציה, לדוגמה:

סוג M = סט של B;

כאשר M הוא סוג הרבים, B הוא סוג הבסיס.

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

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

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

1) ['A','B'] + ['A','D'] ייתן ['A','B','D'];

2) ['א'] * ['א','ב','ג'] ייתן ['א'];

3) ['A','B','C'] - ['A','B'] ייתן ['C']

פעולות ישימות לערכים מרובים: זהות (=), אי-זהות (<>), הכלולה ב-(<=), מכילה (>=). לתוצאה של פעולות אלה יש סוג בוליאני:

1) ['A','B'] = ['A','C'] ייתן FALSE;

2) ['א','ב'] <> ['א','ג'] ייתן TRUE;

3) ['B'] <= ['B','C'] ייתן TRUE;

4) ['C','D'] >= ['A'] ייתן FALSE.

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

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

14. קבצים. פעולות קובץ

סוג נתוני הקובץ מגדיר אוסף מסודר של רכיבים מאותו סוג.

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

קבצי טקסט

כדי לתאר קבצים כאלה, יש סוג טקסט:

var TF1, TF2: טקסט;

קבצי רכיבים

רכיב או קובץ מודפס הוא קובץ עם הסוג המוצהר של רכיביו.

סוג M = File Of T;

כאשר M הוא שם סוג הקובץ;

T - סוג רכיב. הפעולות מתבצעות באמצעות נהלים.

כתוב(f, X1,X2,...XK)

קבצים לא מודפסים

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

var f: קובץ;

1. Procedure Assign(var F; FileName: String); זה ממפה שם קובץ למשתנה.

2. נוהל Close(var F);

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

3.פונקציה Eof(var F): בוליאנית;

{קבצים שהוקלדו או לא הוקלדו}

פונקציה Eof[(var F: Text)]: בוליאנית;

{קבצי טקסט}

בודק את סוף הקובץ.

4. Procedure Erase(varF);

מוחק את הקובץ החיצוני המשויך ל-F.

5. פונקציה FileSize(var F): מספר שלם;

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

6.Function FilePos(varF): LongInt;

מחזירה את המיקום הנוכחי בתוך קובץ.

7. איפוס הליך (var F [: File; RecSize: Word]);

פותח קובץ קיים.

8. הליך שכתוב (var F: File [; גודל מחדש: Word]);

יוצר ופותח קובץ חדש.

9. Procedure Seek(var F; N: LongInt);

מעביר את מיקום הקובץ הנוכחי לרכיב שצוין.

10. נוהל Append(var F: Text);

חיבור.

11.פונקציה Eoln[(var F: Text)]: בוליאני;

בודק את הסוף של מחרוזת.

12. הליך קריאה (F, V1 [, V2..., Vn]);

{קבצים שהוקלדו ולא הוקלדו}

Procedure Read([var F: Text;] V1 [, V2..., Vn]);

{קבצי טקסט}

קורא רכיב קובץ למשתנה.

13. נוהל Readln([var F: Text;] V1 [, V2..., Vn]);

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

14. פונקציה SeekEof[(var F: Text)]: Boolean;

מחזיר את סימן סוף הקובץ. משמש רק עבור קבצי טקסט פתוחים.

15. הליך Writeln([var F: Text;] [P1, P2..., Pn]);

{קבצי טקסט}

מבצע פעולת כתיבה ולאחר מכן מציב סמן של סוף שורה בקובץ.

15. מודולים. סוגי מודולים

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

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

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

1) רכיבי תוכנית המיועדים לשימוש על ידי תוכניות או מודולים אחרים, רכיבים כאלה נקראים גלויים מחוץ למודול;

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

unit <שם מודול>; {כותרת מודול}

ממשק

{תיאור של רכיבי תוכנית גלויים של המודול}

הפעלה

{תיאור של רכיבי התכנות הנסתרים של המודול}

להתחיל

{הצהרות אתחול של רכיב מודול}

הסוף.

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

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

1. מודול מערכת.

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

2. מודול DOS.

מודול ה-Dos מיישם מספר שגרות ופונקציות של Pascal המקבילות לקריאות ה-DOS הנפוצות ביותר, כגון GetTime, SetTime, DiskSize וכן הלאה.

3. מודול CRT.

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

4. מודול GRAPH.

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

5. מודול OVERLAY.

מודול OVERLAY מאפשר לך לצמצם את דרישות הזיכרון של תוכנית DOS במצב אמיתי.

16. סוג נתוני הפניה. זיכרון דינמי. משתנים דינמיים. עבודה עם זיכרון דינמי

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

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

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

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

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

var p1, p2: ^real;

p3, p4: ^מספר שלם;

...

נהלים ופונקציות של זיכרון דינמי

1. נוהל חדש{var p: Pointer).

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

2. נוהל Dispose(var p: Pointer).

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

3. הליך GetMem(var p: Pointer; גודל: Word).

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

4. הליך FreeMem (varp: Pointer; גודל: Word).

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

5. ההליך Mark{var p: Pointer) כותב למצביע p את הכתובת של תחילת קטע הזיכרון הדינמי הפנוי בזמן הקריאה שלו.

6. פרוצדורה Release(var p: Pointer) משחררת קטע של זיכרון דינמי, החל מהכתובת שנכתבה למצביע p על ידי נוהל Mark, כלומר מנקה את הזיכרון הדינמי שהיה תפוס לאחר הקריאה לפרוצדורת Mark.

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

8. פונקציה MemAvail: Longint מחזירה את הכמות הכוללת של זיכרון דינמי פנוי בבתים.

9. פונקציית העזר SizeOf(X):Word מחזירה את הגודל בבתים שתפוסים על ידי X, כאשר X יכול להיות שם משתנה מכל סוג או שם סוג.

17. מבני נתונים מופשטים

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

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

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

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

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

1) הוספת אלמנט לרשימה;

2) הסרת אלמנט מהרשימה עם מפתח נתון;

3) חפש אלמנט עם ערך נתון של שדה המפתח;

4) מיון מרכיבי הרשימה;

5) חלוקת הרשימה לשתי רשימות או יותר;

6) שילוב של שתי רשימות או יותר לאחת;

7) פעולות אחרות.

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

18. ערימות

מחסנית היא מבנה נתונים דינמי, תוספת של רכיב אליו והסרה של רכיב ממנו עשויים מקצה אחד, הנקרא החלק העליון של הערימה. המחסנית עובדת על העיקרון של LIFO (Last-In, First-Out) - "Last in, first out".

בדרך כלל מבוצעות שלוש פעולות בערימות:

1) היווצרות ראשונית של הערימה (רשומה של הרכיב הראשון);

2) הוספת רכיב לערימה;

3) בחירת הרכיב (מחיקה).

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

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

תוכנית STACK;

משתמש ב- Crt;

סוג

Alpha = String[10];

PComp = ^Comp;

Comp = שיא

SD: אלפא;

pNext: PComp

הסוף;

היה

pTop:PComp;

sc: אלפא;

Create ProcedureStack(var pTop: PComp; var sC: Alfa);

להתחיל

חדש(pTop);

pTop^.pNext:= NIL;

pTop^.sD:= sC;

הסוף;

הוסף ProcedureComp(var pTop: PComp; var sC: Alfa);

var pAux: PComp;

להתחיל

NEW(pAux);

pAux^.pNext:= pTop;

pTop:=pAux;

pTop^.sD:= sC;

הסוף;

נוהל DelComp(var pTop: PComp; var sC: ALFA);

להתחיל

sC:= pTop^.sD;

pTop:= pTop^.pNext;

הסוף;

להתחיל

Clrscr;

writeln( ENTER STRING );

readln(sc);

CreateStack(pTop, sc);

לחזור על

writeln( ENTER STRING );

readln(sc);

AddComp(pTop, sc);

עד sC = 'END';

19. תורים

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

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

ProgramQUEUE;

משתמש ב- Crt;

סוג

Alpha = String[10];

PComp = ^Comp;

Comp = שיא

SD: אלפא;

pNext:PComp;

הסוף;

היה

pBegin, pEnd: PComp;

sc: אלפא;

Create ProcedureQueue(var pBegin,pEnd: PComp; var

sc: אלפא);

להתחיל

חדש(pBegin);

pBegin^.pNext:= NIL;

pBegin^.sD:= sC;

pEnd:=pBegin;

הסוף;

הליך AddQueue(var pEnd: PComp; var sC:

אלפא);

var pAux: PComp;

להתחיל

חדש(pAux);

pAux^.pNext:= NIL;

pEnd^.pNext:= pAux;

pEnd:= pAux;

pEnd^.sD:= sC;

הסוף;

נוהל DelQueue(var pBegin: PComp; var sC:

אלפא);

להתחיל

sC:=pBegin^.sD;

pBegin:= pBegin^.pNext;

הסוף;

להתחיל

Clrscr;

writeln( ENTER STRING );

readln(sc);

CreateQueue(pBegin, pEnd, sc);

לחזור על

writeln( ENTER STRING );

readln(sc);

AddQueue(pEnd, sc);

עד sC = 'END';

20. מבני נתונים עצים

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

אם נשתמש בהגדרה הרקורסיבית שהוצעה על ידי N. Wirth, אזי מבנה נתוני עץ עם סוג בסיס t הוא או מבנה ריק או צומת מסוג t, שאיתו קבוצה סופית של מבני עץ עם סוג בסיס t, הנקראים תת-עצים, היא קשור ל.

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

אם הצומת y ממוקם ישירות מתחת לצומת x, אזי הצומת y נקרא הצאצא המיידי של הצומת x, ו-x הוא האב הקדמון המיידי של הצומת y, כלומר, אם הצומת x נמצא ברמה ה-i, אז הצומת y הוא בהתאם. ממוקם ברמה (i + 1) - ה'.

הרמה המקסימלית של צומת עץ נקראת גובה או עומק העץ. לאב קדמון אין רק צומת אחד של העץ - השורש שלו.

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

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

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

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

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

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

21. פעולות על עצים

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

אנו מציגים אלגוריתם לבניית עץ מסודר.

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

2. כדי להוסיף צומת לעץ שכבר קיים, אתה יכול להשתמש באלגוריתם שלמעלה.

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

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

II. חפש צומת עם ערך שדה מפתח נתון.

בעת ביצוע פעולה זו, יש צורך לחצות את העץ. יש צורך לקחת בחשבון את הצורות השונות של כתיבת עץ: קידומת, infix ו-postfix.

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

TYPE TreeLink = ^Tree;

עץ = שיא;

Inf: <סוג נתונים>;

שמאל, ימין: TreeLink;

סוף.

22. דוגמאות לביצוע פעולות

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

אלגוריתם בנייה רקורסיבית:

1) הצומת הראשון נלקח כשורש העץ;

2) תת העץ השמאלי של צמתים nl בנוי באותו אופן;

3) תת העץ הימני של צמתים nr בנוי באותו אופן;

nr = n - nl - 1

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

עץ פונקציה(n: Byte): TreeLink;

Vart: TreeLink; nl,nr,x: Byte;

להתחיל

אם n = 0 אז Tree:= nil

אחר

להתחיל

nl:= n div 2;

nr = n - nl - 1;

writeln('הזן מספר קודקוד);

readln(x);

new(t);

t^.inf:= x;

t^.left:= Tree(nl);

t^.right:= Tree(nr);

עץ:=t;

סוף;

{עֵץ}

סוף.

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

הליך חיפוש (x: Byte; var t: TreeLink);

להתחיל

אם t = אפס אז

להתחיל

חדש(ט);

t^inf:= x;

t^.left:= nil;

t^.right:= אפס;

סוֹף

אחרת אם x < t^.inf אז

חפש (x, t^.left)

אחרת אם x > t^.inf אז

חפש (x, t^.right)

אחר

להתחיל

{process found element}

...

סוף;

סוף.

23. הרעיון של גרף. דרכים לייצוג גרף

גרף הוא זוג G = (V,E), כאשר V הוא קבוצה של עצמים בעלי אופי שרירותי, הנקראים קודקודים, ו-E היא משפחה של זוגות ei = (vil, vi2), vijOV, הנקראים קצוות. במקרה הכללי, קבוצת V ו(או) משפחת E יכולים להכיל מספר אינסופי של אלמנטים, אך נשקול רק גרפים סופיים, כלומר גרפים שעבורם גם V וגם E הם סופיים. אם סדר האלמנטים הנכללים באי משנה, אז הגרף נקרא מכוון, מקוצר - דיגרף, אחרת - בלתי מכוון. הקצוות של דיגרף נקראים קשתות.

אם e = , אז הקודקודים v ו-u נקראים קצוות הקצה. במקרה זה, אומרים שהקצה e צמוד (מתרחש) לכל אחד מהקודקודים v ו-u. קודקודים v ו ו נקראים גם סמוכים (אירוע). במקרה הכללי, קצוות הצורה e = ; קצוות כאלה נקראים לולאות.

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

משקלו של צומת הוא מספר (אמיתי, שלם או רציונלי) המוקצה לצומת נתון (מתפרש כעלות, תפוקה וכו').

נתיב בגרף (או מסלול בדיגרף) הוא רצף מתחלף של קודקודים וקצוות (או קשתות בדיגרף) בצורה v0, (v0,v1), v1,..., (vn -1, vn), vn. המספר n נקרא אורך הנתיב. נתיב ללא קצוות חוזרים נקרא שרשרת; נתיב ללא קודקודים חוזרים נקרא שרשרת פשוטה. שביל סגור ללא קצוות חוזרים נקרא מחזור (או

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

גרף נקרא מחובר אם יש נתיב בין כל שני קודקודים שלו, ומנותק אחרת.

ישנן דרכים שונות לייצוג גרפים.

1. מטריצת שכיחות.

זוהי מטריצה מלבנית n x m, כאשר n הוא מספר הקודקודים ו-m הוא מספר הקצוות.

2. מטריצת סמיכות.

זוהי מטריצה מרובעת של ממדים n × n, כאשר n הוא מספר הקודקודים.

3. רשימת סמיכות (תקריות). מייצג מבנה נתונים ש

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

4. רשימת רשימות.

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

24. ייצוגי גרפים שונים

כדי ליישם גרף כרשימת שכיחות, אתה יכול להשתמש בסוג הבא:

TypeList = ^S;

S=שיא;

inf: Byte;

הבא: רשימה;

הסוף;

לאחר מכן, הגרף מוגדר כך:

Vargr: מערך[1..n] של רשימה;

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

בפסקל, הליך המעבר לעומק ראשון ייראה כך:

נוהל Obhod(gr: Graph; k: Byte);

Varg: גרף; l: רשימה;

להתחיל

nov[k]:= false;

g:=gr;

בעוד g^.inf <> k do

g:= g^.next;

l:= g^.smeg;

בעוד אני <> אפס כן מתחילים

אם nov[l^.inf] אז Obhod(gr, l^.inf);

l:= l^.הבא;

סוף;

הצגת גרף כרשימה של רשימות

ניתן להגדיר גרף באמצעות רשימה של רשימות באופן הבא:

TypeList = ^Tlist;

tlist=record

inf: Byte;

הבא: רשימה;

הסוף;

גרף = ^TGpaph;

TGpaph = שיא

inf: Byte;

smeg: רשימה;

הבא: גרף;

הסוף;

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

הנה הליך למעבר גרף ברוחב בפסאודוקוד:

נוהל Obhod2(v);

להתחיל

תור = O;

תור <= v;

nov[v] = שקר;

בעוד תור <> O לעשות

להתחיל

p <= תור;

עבור u in spisok(p) לעשות

אם חדש[u] אז

להתחיל

nov[u]:= שקר;

תור <= u;

סוף;

25. סוג אובייקט בפסקל. מושג החפץ, התיאור והשימוש בו

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

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

2) ירושה. הגדרה של אובייקט ושימוש נוסף בו לבניית היררכיה של אובייקטים צאצאים עם היכולת של כל אובייקט צאצא הקשור להיררכיה לגשת לקוד ולנתונים של כל אובייקטי האב;

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

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

סוג אובייקט יכול לרשת רכיבים מסוג אובייקט אחר. אם סוג T2 יורש מסוג T1, אזי סוג T2 הוא ילד מסוג G, וסוג G עצמו הוא אב מסוג G2.

קוד המקור הבא מספק דוגמה להצהרת סוג אובייקט.

סוג

נקודה = אובייקט

X, Y: מספר שלם;

הסוף;

Rect = חפץ

A, B: TPoint;

פרוצדורה Init(XA, YA, XB, YB: מספר שלם);

הליך Copy(var R: TRectangle);

פרוצדורה Move(DX, DY: מספר שלם);

הליך Grow(DX, DY: מספר שלם);

procedure Intersect(var R: TRectangle);

procedure Union(var R: TRectangle);

function Contains(P: Point): Boolean;

הסוף;

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

לסוג רכיב מסוג קובץ לא יכול להיות סוג אובייקט או כל סוג מבנה המכיל רכיבים מסוג אובייקט.

26. ירושה

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

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

ניתן להשתמש בשדות ובשיטות שעברו בירושה ללא שינוי או להגדיר מחדש (שונה).

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

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

סוּג

<שם סוג> = אובייקט [(<שם סוג אב>)]

([<scope>]

<תיאור של שדות ושיטות>)+

הסוף;

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

ההיקף הוא אחת ממילות המפתח הבאות:

▪ פרטי;

▪ מוגן;

▪ ציבורי.

ה-scope מאפיין לאילו חלקים של התוכנית יהיו זמינים הרכיבים שהתיאורים שלהם עוקבים אחר מילת המפתח ששמה להיקף זה.

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

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

27. יצירת אובייקטים

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

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

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

אם מופע האובייקט לא מאותחל ובדיקת טווח מופעלת (על פי ההנחיה {$R+}), אז הקריאה הראשונה למתודה הוירטואלית של מופע האובייקט נותנת שגיאת זמן ריצה. אם בדיקת הטווח מושבתת על ידי ההנחיה {$R-}), אז הקריאה הראשונה לשיטה וירטואלית של אובייקט לא מאותחל עלולה להוביל להתנהגות בלתי צפויה.

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

היה

הערה: מערך [1..5] של TStrField;

אני: מספר שלם

להתחיל

עבור I:= 1 עד 5 do

הערה [I].Init (1, I + 10, 40, 'first_name');

עבור I:= 1 עד 5 do Comment [I]. Done;

הסוף;

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

היה

SP: StrFieldPtr;

להתחיל

New(SP, Init(1, 1, 25, 'first_name');

SP^.Put('Vladimir');

SP^.תצוגה;

השלך (SP, Done);

הסוף.

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

28. רכיבים והיקף

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

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

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

סוּג

<שם סוג> = אובייקט [(<שם סוג אב>)]

פְּרָטִי

<תיאורים פרטיים של שדות ושיטות>

מוּגָן

<תיאורי שדות ושיטות מוגנים>

הציבור

<תיאורים פומביים של שדות ושיטות>

הסוף;

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

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

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

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

29. שיטות

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

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

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

שיטות וירטואליות

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

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

שיטות דינמיות

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

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

הליך FileOpen(var Msg: TMessage); וירטואלי 100;

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

30. קונסטרוקטים והורסים

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

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

הנה כמה דוגמאות לבנאים:

בנאי Field.Copy(var F: Field);

להתחיל

עצמי:=F;

הסוף;

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

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

שים לב

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

ההורס שדה בוצע;

להתחיל

FreeMem(שם, אורך(שם^) + 1);

הסוף;

משמיד StrField.Done;

להתחיל

FreeMem(Value, Len);

השדה נעשה;

הסוף;

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

31. הורסים

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

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

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

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

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

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

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

destructorAnObject.Done;

להתחיל

הסוף;

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

32. שיטות וירטואליות

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

להלן האובייקטים מהמשכורת לדוגמה, וירטואליים כהלכה:

סוּג

PEmployee = ^TEmployee;

עובד עבודה = חפץ

שם, כותרת: מחרוזת[25];

תעריף: אמיתי;

הבנאי Init(AName, ATitle: String; ARate: Real);

פונקציה GetPayAmount: אמיתי; וירטואלי;

function GetName: מחרוזת;

פונקציה GetTitle: מחרוזת;

פונקציה GetRate: Real;

הליך הצג; וירטואלי;

הסוף;

PHourly = ^THourly;

THourly = object(TEmployee);

זמן: מספר שלם;

הבנאי Init(AName, ATitle: String; ARate: Real;

זמן: מספר שלם);

פונקציה GetPayAmount: אמיתי; וירטואלי;

פונקציה GetTime: מספר שלם;

הסוף;

PSalaried = ^TSalaried;

TSalaried = object(TEmployee);

פונקציה GetPayAmount: אמיתי; וירטואלי;

הסוף;

Pcommissioned = ^Tcommissioned;

TCommissioned = object(Laried);

עמלה: ריאל;

סכום מכירה: אמיתי;

הבנאי Init(AName, ATitle: String; ARate,

ACommission, ASalesmount: Real);

פונקציה GetPayAmount: אמיתי; וירטואלי;

הסוף;

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

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

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

33. שדות נתוני אובייקט ופרמטרים של שיטה פורמלית

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

הליך CrunchIt(Crunchee: MyDataRec, Crunchby,

ErrorCode: מספר שלם);

היה

א,ב: char;

ErrorCode: מספר שלם;

להתחיל

הסוף;

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

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

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

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

34. אנקפסולציה

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

לדוגמה, האובייקטים TEmployee ו-THourly נכתבים בצורה כזו שאין שום צורך לגשת ישירות לשדות הנתונים הפנימיים שלהם:

סוג

עובד עבודה = חפץ

שם, כותרת: מחרוזת[25];

תעריף: אמיתי;

procedure Init(AName, ATitle: string; ARate: Real);

function GetName: מחרוזת;

פונקציה GetTitle: מחרוזת;

פונקציה GetRate: Real;

פונקציה GetPayAmount: אמיתי;

הסוף;

THourly = object(TEmployee)

זמן: מספר שלם;

הליך Init(AName, ATitle: מחרוזת; ARate:

אמיתי, זמן: מספר שלם);

פונקציה GetPayAmount: אמיתי;

הסוף;

יש כאן רק ארבעה שדות נתונים: שם, כותרת, קצב וזמן. השיטות GetName ו-GetTitle מציגות את שם המשפחה והתפקיד של העובד, בהתאמה. שיטת GetPayAmount משתמשת ב-Rate, ובמקרה של עבודה THourly and Time כדי לחשב את כמות התשלומים לעבודה. אין עוד צורך להתייחס ישירות לשדות הנתונים הללו.

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

עם לעשות לפי שעה

להתחיל

אינית (אלכסנדר פטרוב, מפעיל מלגזות' 12.95, 62);

{מציג את שם המשפחה, המיקום והסכום

תשלומים}

הצג;

הסוף;

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

35. הרחבת חפצים

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

הבה נגדיר סוג ילד של TEmployee המייצג עובד שמשולם לו תעריף שעתי בדוגמה הבאה:

const

PayPeriods = 26; { תקופות תשלום }

סף שעות נוספות = 80; { לתקופת התשלום }

OvertimeFactor = 1.5; { תעריף לשעה }

סוג

THourly = object(TEmployee)

זמן: מספר שלם;

הליך Init(AName, ATitle: מחרוזת; ARate:

אמיתי, זמן: מספר שלם);

פונקציה GetPayAmount: אמיתי;

הסוף;

הליך THourly.Init(AName, ATitle: string;

ARate: אמיתי, זמן: מספר שלם);

להתחיל

TEmployee.Init(AName, ATitle, ARate);

זמן:= ATime;

הסוף;

function THourly.GetPayAmount: אמיתי;

היה

שעות נוספות: מספר שלם;

להתחיל

שעות נוספות:= זמן - סף תוספת זמן;

אם הארכה > 0 אז

GetPayAmount:= RoundPay(סף שעות נוספות * תעריף

RateOverTime * OvertimeFactor

*ציון)

אחר

GetPayAmount:= RoundPay (זמן * תעריף)

הסוף;

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

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

36. תאימות סוגי אובייקטים

ירושה משנה את כללי תאימות הסוג של Borland Pascal במידה מסוימת. צאצא יורש את תאימות הסוג של כל אבותיו.

תאימות סוגים מורחבת זו לובשת שלוש צורות:

1) בין מימושים של אובייקטים;

2) בין מצביעים למימושי אובייקט;

3) בין פרמטרים פורמליים לממשיים. תאימות סוגים משתרעת רק מילד להורה.

לדוגמה, TSalaried הוא ילד של TEmployee ו- TCommissioned הוא ילד של TSalaried. שקול את התיאורים הבאים:

היה

AnEmployee: TEmployee;

ASalaried: TSalaried;

Pcommissioned: TCommissioned;

TEmployeePtr: ^TEmployee;

TSalariedPtr: ^TSalaried;

TCommissionedPtr: ^Tcommissioned;

תחת תיאורים אלה, אופרטורי ההקצאה הבאים תקפים:

AnEmployee:=משכיר;

ASalaried:= אמומלץ;

TCommissionedPtr:= ACommissioned;

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

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

AnEmployee:= ACommissioned;

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

TSalariedPtr:= TCommissionedPtr;

TEmployeePtr:= TSalariedPtr;

TEmployeePtr:= PCommissionedPtr;

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

הליך CalcFedTax(קורבן: TSalaried);

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

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

37. על אסמבלר

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

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

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

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

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

38. דגם תוכנה של המיקרו-מעבד

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

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

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

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

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

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

ניתן לחלק את המאגרים הללו לשתי קבוצות גדולות:

1) 16 רישומי משתמשים;

2) 16 אוגרי מערכת.

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

בנוסף לרגיסטרים המפורטים לעיל, מפתחי מעבדים מציגים אוגרים נוספים למודל התוכנה שנועד לייעל מחלקות חישובים מסוימות. אז, במשפחת מעבדי ה-Pentium Pro (MMX) של תאגיד אינטל, הוצגה הרחבה MMX מבית אינטל. הוא כולל 8 (MM0-MM7) אוגרים של 64 סיביות ומאפשר לך לבצע פעולות שלמים על זוגות של מספר סוגי נתונים חדשים:

1) שמונה בתים ארוזים;

2) ארבע מילים ארוזות;

3) שתי מילים כפולות;

4) מילה מרובעת;

במילים אחרות, עם הוראת הרחבה אחת של MMX, מתכנת יכול, למשל, להוסיף שתי מילים כפולות יחד. מבחינה פיזית, לא נוספו אוגרים חדשים. MM0-MM7 הן המנטיסה (64 סיביות נמוכות יותר) של ערימה של 80 סיביות FPU (יחידת נקודה צפה - מעבד שיתוף).

בנוסף, כרגע יש את ההרחבות הבאות של מודל התכנות - 3DNOW! מ-AMD; SSE, SSE2, SSE3, SSE4. 4 ההרחבות האחרונות נתמכות הן על ידי מעבדי AMD והן על ידי אינטל.

39. רישומי משתמשים

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

1) שמונה אוגרים של 32 סיביות שיכולים לשמש מתכנתים לאחסון נתונים וכתובות (הם נקראים גם אוגרים למטרות כלליות (RON)):

▪ eax/ax/ah/al;

▪ ebx/bx/bh/bl;

▪ edx/dx/dh/dl;

▪ ecx/cx/ch/cl;

▪ ebp/bp;

▪ esi/si;

▪ edi/di;

▪ esp/sp.

2) שישה אוגרי מקטעים:

▪ cs;

▪ ds;

▪ ss;

▪ es;

▪fs;

▪gs;

3) אוגרי סטטוס ושליטה:

▪ דגלים רושמים אפלוגים/דגלים;

▪ רישום מצביע פקודה eip/ip.

האיור הבא מציג את האוגרים הראשיים של המיקרו-מעבד:

פנקסי מטרה כלליים

40. רישומים כלליים

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

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

1) eax/ax/ah/al (אוגר מצבר) - סוללה. משמש לאחסון נתוני ביניים. בפקודות מסוימות, השימוש ברישום זה הוא חובה;

2) ebx/bx/bh/bl (בסיס אוגר) - אוגר בסיס. משמש לאחסון כתובת הבסיס של אובייקט כלשהו בזיכרון;

3) ecx/cx/ch/cl (אוגר ספירה) - אוגר מונה. הוא משמש בפקודות שמבצעות כמה פעולות שחוזרות על עצמן. השימוש בו לרוב מרומז ומוסתר באלגוריתם של הפקודה המתאימה.

לדוגמה, פקודת ארגון הלולאה, בנוסף להעברת השליטה לפקודה הממוקמת בכתובת מסוימת, מנתחת ומורידה את הערך של האוגר ecx/cx באחד;

4) edx/dx/dh/dl (מאגר נתונים) - אוגר נתונים.

בדיוק כמו האוגר eax/ax/ah/al, הוא מאחסן נתוני ביניים. פקודות מסוימות דורשות שימוש בה; עבור פקודות מסוימות זה קורה באופן מרומז.

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

1) esi/si (מאגר אינדקס מקור) - אינדקס מקור. אוגר זה בפעולות שרשרת מכיל את הכתובת הנוכחית של האלמנט בשרשרת המקור;

2) edi/di (register Destination Index) - אינדקס של המקבל (הנמען). פנקס זה בפעולות שרשרת מכיל את הכתובת הנוכחית בשרשרת היעד.

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

1) esp/sp (Stack Pointer Register) - אוגר מצביע מחסנית. מכיל מצביע לראש הערימה בקטע הערימה הנוכחי.

2) ebp/bp (Base Pointer register) - אוגר מצביע בסיס של מסגרת מחסנית. נועד לארגן גישה אקראית לנתונים בתוך הערימה.

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

41. פנקסי פלחים

ישנם שישה אוגרי מקטעים במודל תוכנת המיקרו-מעבד: cs, ss, ds, es, gs, fs.

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

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

המיקרו-מעבד תומך בסוגי המקטעים הבאים.

1. קטע קוד. מכיל פקודות תוכנית. כדי לגשת לקטע זה, נעשה שימוש ב-cs register (code segment register) - אוגר קוד המקטע. הוא מכיל את הכתובת של מקטע הוראות המכונה שאליו יש למיקרו-מעבד גישה (כלומר, הוראות אלה נטענות בצינור המיקרו-מעבד).

2. פלח נתונים. מכיל את הנתונים המעובדים על ידי התוכנית. כדי לגשת למקטע זה, נעשה שימוש ב-ds (register data segment) - אוגר נתוני סגמנט המאחסן את הכתובת של מקטע הנתונים של התוכנית הנוכחית.

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

4. פלח נתונים נוספים. באופן מרומז, האלגוריתמים לביצוע רוב הוראות המכונה מניחים שהנתונים שהם מעבדים ממוקמים בקטע הנתונים, שכתובתו נמצאת ב-ds segment register. אם מקטע נתונים אחד אינו מספיק לתוכנית, יש לה הזדמנות להשתמש בעוד שלושה מקטעי נתונים נוספים. אבל בניגוד למקטע הנתונים הראשי, שכתובתו כלולה ב-ds segment register, בעת שימוש במקטעי נתונים נוספים, יש לציין את הכתובות שלהם במפורש באמצעות קידומות הגדרה מחדש של מקטעים בפקודה. כתובות של מקטעי נתונים נוספים חייבות להיכלל ברגיסטרים es, gs, fs (אוגרי מקטעי הרחבה).

42. אוגרי סטטוס ובקרה

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

1) דגלים אוגרות דגלים;

2) אוגר מצביע פקודה eip/ip.

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

1. eflags/flags (אוגר דגלים) - פנקס דגלים. עומק הסיביות של eflags/דגלים הוא 32/16 סיביות. לסיביות בודדות של אוגר זה יש מטרה פונקציונלית ספציפית והן נקראות דגלים. החלק התחתון של האוגר הזה הוא אנלוגי לחלוטין למאגר הדגלים עבור i8086.

בהתאם לאופן השימוש בהם, ניתן לחלק את הדגלים של מאגר האפלגים/דגלים לשלוש קבוצות:

1) שמונה דגלי סטטוס.

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

2) דגל בקרה אחד.

מסומן df (דגל ספרייה). הוא ממוקם בסיביות 10 של אוגר eflags ומשמש על ידי פקודות משורשרות. הערך של דגל df קובע את כיוון העיבוד של אלמנט אחר אלמנט בפעולות אלו: מתחילת המחרוזת ועד הסוף (df = 0) או להיפך, מסוף המחרוזת לתחילתה (df = 1). כדי לעבוד עם דגל df, ישנן פקודות מיוחדות: cld (הסר את דגל df) ו-std (הגדר את דגל df).

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

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

2. eip/ip (Instraction Pointer register) - אוגר מצביע הוראות. אוגר ה-eip/ip הוא ברוחב 32/16 סיביות ומכיל את ההיסט של ההוראה הבאה שתתבצע ביחס לתוכן של אוגר המקטע cs בקטע ההוראה הנוכחי. אוגר זה אינו נגיש ישירות למתכנת, אך ערכו נטען ומשתנה על ידי פקודות בקרה שונות, הכוללות פקודות לקפיצות מותנות ובלתי מותנות, קריאה לפרוצדורות וחזרה מהליכים. התרחשות של פסיקות משנה גם את אוגר ה-eip/ip.

43. אוגרי מערכת מיקרו-מעבדים

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

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

1) ארבעה אוגרי בקרה;

קבוצת אוגרי הבקרה כוללת 4 אוגרים:

▪ cr0;

▪ cr1;

▪ cr2;

▪ cr3;

2) ארבעה אוגרי כתובות מערכת (הנקראים גם אוגרי ניהול זיכרון);

אוגרי הכתובות של המערכת כוללים את האוגרים הבאים:

▪ אוגר טבלת מתאר גלובלי gdtr;

▪ רישום טבלת מתאר מקומי Idtr;

▪ רישום טבלת מתאר פסיקה idtr;

▪ אוגר משימות 16 סיביות tr;

3) שמונה אוגרי ניפוי באגים. אלו כוללים:

▪ dr0;

▪ dr1;

▪ dr2;

▪ dr3;

▪ dr4;

▪ dr5;

▪ dr6;

▪ dr7.

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

44. אוגרי בקרה

קבוצת אוגרי הבקרה כוללת ארבעה אוגרים: cr0, cr1, cr2, cr3. אוגרים אלו מיועדים לבקרת מערכת כללית. אוגרי בקרה זמינים רק לתוכניות עם רמת הרשאה 0.

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

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

מטרת דגלי המערכת:

1) pe (Protect Enable), סיביות 0 - אפשר מצב מוגן. המצב של דגל זה מציין באיזה משני המצבים - אמיתי (pe = 0) או מוגן (pe = 1) - המיקרו-מעבד פועל בזמן נתון;

2) mp (Math Present), bit 1 - נוכחות של מעבד משותף. תמיד 1;

3) ts (Task Switched), סיביות 3 - החלפת משימות. המעבד מגדיר אוטומטית סיביות זו כאשר הוא עובר למשימה אחרת;

4) am (מסכת יישור), סיביות 18 - מסכת יישור.

סיביות זו מאפשרת (am = 1) או משביתה (am = 0) בקרת יישור;

5) cd (השבתת מטמון), סיביות 30 - השבתת זיכרון מטמון.

באמצעות סיביות זו, אתה יכול להשבית (cd = 1) או לאפשר (cd = 0) את השימוש במטמון הפנימי (המטמון ברמה הראשונה);

6) pg (PaGing), סיביות 31 - אפשר (pg = 1) או השבת (pg = 0) איתור.

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

האוגר cr2 משמש בהחלפת RAM כדי לרשום את המצב שבו ההוראה הנוכחית ניגשה לכתובת הכלולה בדף זיכרון שאינו נמצא כעת בזיכרון.

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

האוגר cr3 משמש גם לזיכרון ההחלפה. זהו מה שנקרא מרשם ספריית העמודים ברמה הראשונה. הוא מכיל את כתובת הבסיס הפיזית של 20 סיביות של ספריית הדפים של המשימה הנוכחית. ספרייה זו מכילה 1024 מתארים של 32 סיביות, שכל אחד מהם מכיל את הכתובת של טבלת הדפים ברמה השנייה. בתורו, כל אחת מטבלאות העמודים ברמה השנייה מכילה 1024 מתארים של 32 סיביות המטפלים במסגרות עמודים בזיכרון. גודל מסגרת העמוד הוא 4 KB.

45. רישומי כתובות המערכת

אוגרים אלה נקראים גם אוגרי ניהול זיכרון.

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

1) גלובלי - משותף לכל המשימות;

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

1) האוגר של טבלת המתאר הגלובלית gdtr (Global Descriptor Table Register), בעל גודל של 48 סיביות ומכיל כתובת בסיס של 32 סיביות (סיביות 16-47) של טבלת המתאר הגלובלית GDT ו-16 סיביות (סיביות 0-15) ערך גבול, שהוא הגודל בבתים של טבלת GDT;

2) אוגר טבלת המתאר המקומי ldtr (Local Descriptor Table Register), בעל גודל של 16 סיביות ומכיל את מה שנקרא בורר המתארים של טבלת המתארים המקומית LDT. בורר זה הוא מצביע ל-GDT המתאר את הקטע המכיל את טבלת התיאורים המקומית LDT;

3) האוגר של טבלת מתאר הפסיקות idtr (מאגר מתאר פסיקה), בעל גודל של 48 סיביות ומכיל כתובת בסיס של 32 סיביות (סיביות 16-47) של טבלת מתאר הפסיקות IDT ו-16 סיביות (סיביות 0-15) ערך גבול, שהוא גודל בבתים של טבלת IDT;

4) 16-bit task register tr (Task Register), אשר, כמו אוגר ldtr, מכיל בורר, כלומר מצביע לתיאור בטבלת GDT. מתאר זה מתאר את מצב פלח המשימות הנוכחי (TSS). קטע זה נוצר עבור כל משימה במערכת, יש לו מבנה מוסדר בקפדנות ומכיל את ההקשר (המצב הנוכחי) של המשימה. המטרה העיקרית של מקטעי TSS היא לשמור את המצב הנוכחי של משימה ברגע המעבר למשימה אחרת.

46. ניפוי רשומות

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

לרשמים dr0, dr1, dr2, dr3 יש רוחב של 32 סיביות והם מיועדים להגדיר את הכתובות הליניאריות של ארבע נקודות שבירה. המנגנון המשמש במקרה זה הוא הבא: כל כתובת שנוצרת על ידי התוכנית הנוכחית מושווה עם הכתובות באוגרים dr0...dr3, ואם יש התאמה, נוצר חריג באגים עם מספר 1.

אנו מפרטים את הקטעים הללו ואת מטרתם:

1) b0 - אם ביט זה מוגדר ל-1, אז החריגה האחרונה (הפסקה) התרחשה כתוצאה מהגעה לנקודת המחסום שהוגדרה ברישום dr0;

2) b1 - דומה ל-b0, אך עבור מחסום ברישום dr1;

3) b2 - דומה ל-b0, אך עבור מחסום ברישום dr2;

4) b3 - דומה ל-b0, אך עבור מחסום ברישום dr3;

5) bd (סיביות 13) - משמשת להגנה על אוגרי הבאגים;

6) bs (bit 14) - מוגדר ל-1 אם חריג 1 נגרם על ידי מצב הדגל tf = 1 במאגר eflags;

7) bt (סיביות 15) מוגדרת ל-1 אם חריג 1 נגרם על ידי מעבר למשימה עם סיבית הטראפ מוגדרת ב-TSS t = 1. כל שאר הסיביות באוגר זה מלאות באפסים. מטפל חריג 1, בהתבסס על התוכן של dr6, חייב לקבוע את הסיבה שבגללה התרחש החריג ולנקוט את הפעולות הנדרשות.

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

1) מיקום רישום מחסום - רק במשימה הנוכחית או בכל משימה. סיביות אלו תופסות את 8 הסיביות התחתונות של האוגר dr7 (2 סיביות לכל נקודת שבירה (למעשה נקודת שבירה) שנקבעה על ידי האוגרים dr0, drl, dr2, dr3, בהתאמה).

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

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

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

47. מבנה התוכנית ב-assembler

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

הצהרות הרכבה הן מארבעה סוגים.

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

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

הנה דוגמה להוראה שמגדילה את המספר הבינארי המאוחסן באוגר ה-eax באחד:

inc eax

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

דוגמה למאקרו היא המאקרו הבא של סוף התוכנית:

יציאה מאקרו

movax,4c00h

21h אינט

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

להנחיות אין מקבילות בייצוג מכונה; כדוגמה, הנה ההנחיה TITLE שקובעת את הכותרת של קובץ הרישום: %TITLE "Listing 1"

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

; השורה הזו היא הערה

48. תחביר הרכבה

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

תווים חוקיים:

1) כל האותיות הלטיניות: A - Z, a - z;

2) מספרים מ-0 עד 9;

3) סימנים? @, $, &;

4) מפרידים.

האסימונים הם כדלקמן.

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

2. שרשרות תווים - רצפים של תווים המוקפים במרכאות בודדות או כפולות.

3. מספרים שלמים.

סוגים אפשריים של הצהרות אסמבלר.

1. אופרטורים אריתמטיים. אלו כוללים:

1) "+" ו-"-" אונריים;

2) בינאריים "+" ו-"-";

3) כפל "*";

4) חלוקת מספרים שלמים "/";

5) השגת יתרת החלוקה "מוד".

2. אופרטורי Shift מעבירים את הביטוי במספר הסיביות שצוין.

3. אופרטורים להשוואה (החזר "נכון" או "לא נכון") נועדו ליצור ביטויים לוגיים.

4. אופרטורים לוגיים מבצעים פעולות סיביות על ביטויים.

5. אופרטור אינדקס [].

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

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

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

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

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

49. הוראות פילוח

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

שקול אותם בפירוט רב יותר.

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

1) BYTE - יישור לא מבוצע;

2) WORD - הקטע מתחיל בכתובת שהיא כפולה של שתיים, כלומר הביט האחרון (הפחות משמעותי) של הכתובת הפיזית הוא 0 (מיושר לגבול המילה);

3) DWORD - הקטע מתחיל בכתובת שהיא כפולה של ארבע;

4) PARA - הקטע מתחיל בכתובת שהיא כפולה של 16;

5) PAGE - הקטע מתחיל בכתובת שהיא כפולה של 256;

6) MEMPAGE - הקטע מתחיל בכתובת שהיא כפולה של 4 KB.

2. התכונה combine segment (סוג קומבינטורית) אומרת למקשר כיצד לשלב מקטעים של מודולים שונים בעלי אותו שם:

1) PRIVATE - הקטע לא ימוזג עם קטעים אחרים בעלי אותו שם מחוץ למודול זה;

2) PUBLIC - מאלץ את המקשר לחבר את כל המקטעים בעלי אותו שם;

3) COMMON - יש את כל הקטעים עם אותו שם באותה כתובת;

4) AT xxxx - מאתר את הקטע בכתובת המוחלטת של הפסקה;

5) STACK - הגדרה של קטע מחסנית.

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

4. מאפיין גודל פלח:

1) USE16 - זה אומר שהקטע מאפשר כתובת 16 סיביות;

2) USE32 - הקטע יהיה 32 סיביות. צריכה להיות דרך כלשהי לפצות על חוסר האפשרות.

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

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

50. מבנה הוראת מכונה

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

1) מה לעשות?

2) אובייקטים שעליהם צריך לעשות משהו (אלמנטים אלה נקראים אופרנדים);

3) איך לעשות?

האורך המרבי של הוראת מכונה הוא 15 בתים.

1. קידומות.

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

1) קידומת החלפת מקטעים;

2) קידומת אורך סיביות הכתובת מציינת את אורך סיביות הכתובת (32 או 16 סיביות);

3) קידומת אורך סיביות האופרנד דומה לקידומת אורך סיביות הכתובת, אך מציינת את אורך סיביות האופרנד (32 סיביות או 16 סיביות) שאיתה פועלת הפקודה;

4) הקידומת החוזרת משמשת עם פקודות משורשרות.

2. קוד פעולה.

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

3. מצב כתובת בתים modr/m.

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

משמש לחישוב הכתובת האפקטיבית שלו. byte modr/m מורכב משלושה שדות:

1) שדה המוד קובע את מספר הבתים שתפוסים בהוראה על ידי הכתובת של האופרנד;

2) שדה reg/cop קובע את האוגר הממוקם בפקודה במקום האופרנד הראשון, או הרחבה אפשרית של ה-opcode;

3) שדה r/m משמש בשילוב עם שדה mod וקובע או את האוגר הממוקם בפקודה במקום האופרנד הראשון (אם mod = 11), או את אוגרי הבסיס והאינדקס המשמשים לחישוב הכתובת האפקטיבית (יחד עם שדה ההיסט בפקודה).

4. סולם בתים - אינדקס - בסיס (בייט sib). משמש להרחבת אפשרויות ההתייחסות לאופרנדים. ה-sib byte מורכב משלושה שדות:

1) קנה מידה שדות ss. שדה זה מכיל את גורם קנה המידה עבור אינדקס רכיב האינדקס, התופס את 3 הסיביות הבאות של הביט sib;

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

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

5. שדה היסט בפקודה.

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

6. שדה האופרנד המיידי. שדה אופציונלי המייצג 8-,

אופרנד מיידי של 16 או 32 סיביות. הנוכחות של שדה זה באה לידי ביטוי, כמובן, בערך של byte modr/m.

51. שיטות לציון אופרנדים של הוראות

האופרנד מוגדר באופן מרומז ברמת הקושחה

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

האופרנד מצוין בהוראה עצמה (אופרנד מיידי)

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

1) אוגרים של 32 סיביות EAX, EBX, ECX, EDX, ESI, EDI, ESP, EBP;

2) אוגרים של 16 סיביות AX, BX, CX, DX, SI, DI, SP, BP;

3) אוגרים של 8 סיביות AH, AL, BH, BL, CH, CL, DH,

ד.ל.;

4) מקטע רושמת CS, DS, SS, ES, FS, GS. לדוגמה, הפקודה add ax,bx מוסיפה את התוכן של אוגרים ax ו-bx וכותבת את התוצאה ל-bx. הפקודה dec si מורידה את התוכן של si ב-1.

האופרנד נמצא בזיכרון

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

בתורו, לפנייה עקיפה יש את הזנים הבאים:

1) כתובת בסיס עקיפה; שמו השני הוא כתובת עקיפה לרשום;

2) כתובת בסיס עקיפה עם היסט;

3) כתובת אינדקס עקיפה עם היסט;

4) התייחסות לאינדקס בסיס עקיפה;

5) כתובת אינדקס בסיס עקיפה עם היסט.

האופרנד הוא יציאת I/O

בנוסף למרחב כתובות ה-RAM, המיקרו-מעבד שומר על מרחב כתובת I/O, המשמש לגישה להתקני I/O. מרחב כתובות ה-I/O הוא 64 KB. כתובות מוקצות לכל מכשיר מחשב במרחב זה. ערך כתובת מסוים בתוך מרחב זה נקרא יציאת I/O. מבחינה פיזית, יציאת ה-I/O מתאימה לאוגר חומרה (לא להתבלבל עם אוגר מיקרו-מעבד), שאליו ניתן לגשת באמצעות הוראות אסמבלר מיוחדות פנימה והחוצה.

האופרנד נמצא על הערימה

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

1) רישום - רישום;

2) רישום - זיכרון;

3) זיכרון - רישום;

4) אופרנד מיידי - רישום;

5) אופרנד מיידי - זיכרון.

52. דרכי פנייה

פנייה ישירה

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

פנייה ישירה יכולה להיות משני סוגים.

פנייה ישירה יחסית

משמש להוראות קפיצה מותנית לציון כתובת הקפיצה היחסית. היחסיות של מעבר כזה טמונה בעובדה ששדה ההיסט של הוראת המכונה מכיל ערך של 8, 16 או 32 סיביות, שכתוצאה מפעולת ההוראה יתווסף לתוכן של אוגר מצביע ה-ip/eip. כתוצאה מתוספת זו מתקבלת הכתובת שאליה מתבצע המעבר.

פנייה ישירה מוחלטת

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

כתובת עקיפה בסיסית (רישום).

עם הפנייה הזו, הכתובת האפקטיבית של האופרנד יכולה להיות בכל אחד מהאוגרים למטרות כלליות, למעט sp/esp ו-bp/ebp (אלה אוגרים ספציפיים לעבודה עם קטע מחסנית). באופן תחבירי בפקודה, מצב הפנייה הזה מתבטא על ידי הגדר של שם האוגר בסוגריים מרובעים [].

כתובת בסיס עקיפה (אוגר) עם היסט

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

כתובת אינדקס עקיפה עם היסט

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

כתובת אינדקס בסיס עקיפה

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

כתובת אינדקס בסיס עקיפה עם היסט

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

53. פקודות העברת נתונים

פקודות העברת נתונים כלליות

קבוצה זו כוללת את הפקודות הבאות:

1) mov היא פקודת העברת הנתונים העיקרית;

2) xchg - משמש להעברת נתונים דו-כיוונית.

פקודות יציאת קלט/פלט

ביסודו של דבר, ניהול התקנים ישירות דרך יציאות קל:

1) בצובר, מספר יציאה - קלט למצבר מהיציאה עם מספר היציאה;

2) יציאה החוצה, מצבר - פלט את תוכן המצבר ליציאה עם מספר היציאה.

פקודות המרת נתונים

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

מחסנית פקודות

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

המחסנית היא אזור זיכרון שהוקצה במיוחד לאחסון זמני של נתוני התוכנית.

לערימה שלושה אוגרים:

1) ss - אוגר מקטע מחסנית;

2) sp/esp - אוגר מצביע מחסנית;

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

1. push source - כתיבת ערך המקור לראש הערימה.

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

3. pusha - פקודת כתיבה קבוצתית לערימה.

4. pushaw הוא כמעט שם נרדף לפקודת pusha. תכונת bitness יכולה להיות use16 או use32. ר

5. pushad - מבוצע בדומה לפקודה pusha, אבל יש כמה מוזרויות.

שלוש הפקודות הבאות מבצעות את ההפך מהפקודות לעיל:

1) פופה;

2) popaw;

3) פופ.

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

1. pushf - שומר את רישום הדגלים בערימה.

2. pushfw - שמירת אוגר בגודל מילה של דגלים על הערימה. תמיד עובד כמו pushf עם התכונה use16.

3. pushfd - שמירת ה-flags או eflags flags register על הערימה בהתאם לתכונת ה-bit width של הקטע (כלומר, זהה ל-pushf).

באופן דומה, שלוש הפקודות הבאות מבצעות את ההיפך מהפעולות שנדונו לעיל:

1) popf;

2) popfw;

3) popfd.

54. פקודות חשבון

פקודות כאלה פועלות עם שני סוגים:

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

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

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

יש שלוש הוראות הוספה בינארית בערכת הוראות המיקרו-מעבד:

1) אופרנד inc - הגדל את הערך של האופרנד;

2) הוסף אופרנד1, אופרנד2 - הוספה;

3) adc operand1, operand2 - תוספת, תוך התחשבות בדגל הנשיאה cf.

חיסור של מספרים בינאריים ללא סימן

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

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

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

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

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

הפקודה להכפלת מספרים ללא סימנים היא

mul factor_1

הפקודה להכפלת מספרים בסימן היא

[imul operand_1, operand_2, operand_3]

הפקודה div divisor מיועדת לחלוקת מספרים ללא סימנים.

הפקודה idiv divisor מיועדת לחלוקת מספרים חתומים.

55. פקודות לוגיות

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

1. שלילה (לוגית NOT) - פעולה לוגית על אופרנד אחד, שתוצאתה היא ההדדיות של הערך של האופרנד המקורי.

2. תוספת לוגית (לוגית כולל OR) - פעולה לוגית על שני אופרנדים, שתוצאתה היא "אמת" (1) אם אחד האופרנדים או שניהם אמת (1), ו"שקר" (0) אם שני האופרנדים הם שקר (0).

3. כפל לוגי (ולוגי AND) - פעולה לוגית על שני אופרנדים, שתוצאתה נכונה (1) רק אם שני האופרנדים נכונים (1). בכל שאר המקרים, ערך הפעולה הוא "שקר" (0).

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

קבוצת הפקודות הבאה התומכת בעבודה עם נתונים לוגיים:

1) ואופרנד_1, אופרנד_2 - פעולת כפל לוגי;

2) או אופרנד_1, אופרנד_2 - פעולת חיבור לוגית;

3) xor operand_1, operand_2 - פעולת הוספה בלעדית לוגית;

4) test operand_1, operand_2 - פעולת "בדיקה" (בכפל לוגי)

5) לא אופרנד - פעולת שלילה לוגית.

א) כדי להגדיר ספרות מסוימות (סיביות) ל-1, נעשה שימוש בפקודה או operand_1, operand_2;

ב) כדי לאפס ספרות מסוימות (סיביות) ל-0, נעשה שימוש בפקודה ובאופרנד_1, אופרנד_2;

ג) הפקודה xor operand_1, operand_2 מוחלת:

▪ לברר אילו סיביות ב- operand_1 ו- operand_2 שונים;

▪ כדי להפוך את המצב של הסיביות שצוינו לאופרנד_1.

בדיקת הפקודה operand_1, operand_2 (check operand_1) משמשת לבדיקת המצב של הסיביות שצוינו.

התוצאה של הפקודה היא להגדיר את הערך של דגל האפס zf:

1) אם zf = 0, אז כתוצאה מכפל לוגי, מתקבלת תוצאת אפס, כלומר סיביות יחידה אחת של המסכה, שלא תאמה לסיבית היחידה המקבילה של אופרנד1;

2) אם zf = 1, הרי שהכפל הלוגי הביא לתוצאה שאינה אפס, כלומר לפחות סיביות יחידה אחת של המסכה חופפת לסיבית האחת המקבילה של אופרנד1.

כל הוראות ההסטה מזיזות סיביות בשדה האופרנד שמאלה או ימינה בהתאם ל-opcode. לכל הוראות המשמרת יש את אותו מבנה - אופרנד שוטר, מונה משמרת.

56. פקודות העברת בקרה

איזו הוראת תוכנית צריכה להתבצע לאחר מכן, המיקרו-מעבד לומד מהתוכן של cs: (ה) זוג ip register:

1) cs - אוגר מקטע קוד, המכיל את הכתובת הפיזית של מקטע הקוד הנוכחי;

2) eip/ip - אוגר מצביע פקודה, הוא מכיל את ערך ההיסט בזיכרון של ההוראה הבאה שתתבצע.

קפיצות ללא תנאי

מה שצריך לשנות תלוי ב:

1) על סוג האופרנד בהוראת הענף הבלתי מותנית (קרוב או רחוק);

2) מציון משנה לפני כתובת המעבר; במקרה זה, כתובת הקפיצה עצמה יכולה להיות ישירות בהוראה (קפיצה ישירה) או במאגר זיכרון (קפיצה עקיפה).

ערכי שינוי:

1) ליד ptr - מעבר ישיר לתווית;

2) far ptr - מעבר ישיר לתווית בקטע קוד אחר;

3) מילה ptr - מעבר עקיף לתווית;

4) dword ptr - מעבר עקיף לתווית בקטע קוד אחר.

הוראת קפיצה ללא תנאי של jmp

jmp [משנה] jump_address

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

קפיצות מותנות

למיקרו-מעבד 18 הוראות קפיצה מותנות. פקודות אלה מאפשרות לך לבדוק:

1) הקשר בין אופרנדים חתומים ("יותר זה פחות");

2) קשר בין אופרנדים לא חתומים

("גבוהה יותר נמוכה");

3) מצבי דגלים אריתמטיים ZF, SF, CF, OF, PF (אך לא AF).

להוראות קפיצה מותנית יש את אותו תחביר: תווית jcc jump

לפקודת cmp compare יש דרך מעניינת לעבוד. זה בדיוק כמו פקודת החיסור - sub operand_1, operand_2.

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

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

ארגון מחזורים

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

1) תווית מעבר לולאה (Loop) - חזור על הלולאה. הפקודה מאפשרת לך לארגן לולאות בדומה ללולאות בשפות ברמה גבוהה עם הפחתה אוטומטית של מונה הלולאה;

2) תווית קפיצה של loope/loopz

הפקודות loope ו-loopz הן מילים נרדפות מוחלטות;

3) תווית קפיצה של loopne/loopnz

הפקודות loopne ו-loopnz הן גם מילים נרדפות מוחלטות. הפקודות loope/loopz ו-loopne/loopnz הן הדדיות בפעולתן.

מחבר: Tsvetkova A.V.

אנו ממליצים על מאמרים מעניינים סעיף הערות הרצאה, דפי רמאות:

▪ מחלות אף אוזן גרון. הערות הרצאה

▪ פדגוגיה חברתית. עריסה

▪ אנדוקרינולוגיה. עריסה

ראה מאמרים אחרים סעיף הערות הרצאה, דפי רמאות.

תקרא ותכתוב שימושי הערות על מאמר זה.

<< חזרה

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

עור מלאכותי לחיקוי מגע 15.04.2024

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

פסולת חתולים של Petgugu Global 15.04.2024

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

האטרקטיביות של גברים אכפתיים 14.04.2024

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

חדשות אקראיות מהארכיון

ההסתכלות על החולים הופכת אותנו לבריאים יותר 19.02.2011

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

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

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

עוד חדשות מעניינות:

▪ טורבינות רוח משפיעות על האקלים

▪ מטען HTC 3W GaN 65 יציאות

▪ אותות אור של כוכבים

▪ סרט חכם לראש MOOV HR

▪ איסורי אכילה משנים אופי

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

חומרים מעניינים של הספרייה הטכנית החופשית:

▪ קטע אתר התקני מחשב. בחירת מאמרים

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

▪ מדוע המיליארדר פיטרפי היה זקוק לרובוט שיוכל להקליד על מקלדת בשנות ה-1980? תשובה מפורטת

▪ מאמר הפחות איי סונדה. נס טבע

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

▪ מאמר שולחנות קוסם. סוד התמקדות

השאר את תגובתך למאמר זה:

כל השפות של דף זה

בית | הספרייה | מאמרים | <font><font>מפת אתר</font></font> | ביקורות על האתר