הנה משימה אחת: רשימת כל התלמידים עם ציון A. תוכנתן כותבת לולאה — מתחילה מהרקורד הראשון, בודוק את הציון, הוסף את השם לרשימה, עבור…
English narration · English + 中文 subtitles burned in · קריאת קול באנגלית · תרגום אנגלי + סינית שרוף בתוך הסרטון
20.1
Programming paradigms · פרדיגמות תכנות
Syllabus · סיילבוס
English
Candidates should be able to:
Notes and guidance
Understanding what is meant by a programming paradigm
Show understanding of the characteristics of a number of programming paradigms:
• Low-level
Low-level Programming: • understanding of and ability to write low-level code that uses various addressing modes: immediate, direct, indirect, indexed and relative
• Imperative (Procedural)
Imperative (Procedural) programming: • Assumed knowledge and understanding of Structural Programming (see details in AS content section 11.3) • understanding of and ability to write imperative (procedural) programming code that uses variables, constructs, procedures and functions. See details in AS content
• Object Oriented
Object-Oriented Programming (OOP): • understanding of the terminology associated with OOP (including objects, properties/attributes, methods, classes, inheritance, polymorphism, containment (aggregation), encapsulation, getters, setters, instances) • understanding of how to solve a problem by designing appropriate classes • understanding of and ability to write code that demonstrates the use of OOP
• Declarative
Declarative programming: • understanding of and ability to solve a problem by writing appropriate facts and rules based on supplied information • understanding of and ability to write code that can satisfy a goal using facts and rules
עברית
המועמדים צריכים להיות מסוגלים:
הערות והנחיות
הבנה של מהי משמעות Programming Paradigm
הצגת הבנה למאפיינים של מספר פרדיגמות תכנות:
• Low-level
תכנות Low-level: הבנה ויכולת כתיבת קוד low-level המשמש שיטות Addressing Modes שונות: Immediate, Direct, Indirect, Indexed ו-Relative
• אימפרטיבי (פרוצדורלי)
תכנות אימפרטיבי (פרוצדורלי): • ידע והבנה בסיסיים של תכנות מבני (לפרטים עיין בסעיף תוכן AS 11.3) • הבנה ויכולת כתיבת קוד תכנות אימפרטיבי (פרוצדורלי) המשתמש במשתנים, מבנים, פרוצדורות ופונקציות. לפרטים עיין בתוכן AS
• מונחה-אובייקטים
תכנות מונחה-אובייקטים (OOP): • הבנת הטרמינולוגיה הקשורה ל-OOP (כולל אובייקטים, מאפיינים/תכונות, שיטות, קלאסים, ירישה, פולימורפיזם, הכלאה (אגרגציה), אנקפסולציה, מקבלים, נוהגים, מודעים) • הבנה כיצד לפתור בעיה על ידי עיצוב קלאסים מתאימים • הבנה ויכולת כתיבת קוד המדגים שימוש ב-OOP
• צהירותית
תכנות צהירותית: • הבנה ויכולת לפתור בעידה על ידי כתיבת עובדות וחוקים מתאימים על בסיס מידע סופק • הבנה ויכולת כתיבת קוד המסוגל לקיים מטרה באמצעות עובדות וחוקים
Source: Cambridge International syllabus · מקור: הסיילבוס הבינלאומי של קמבריד'ג'
English
A programming paradigm 编程范式 is a style of programming — a way of structuring programs, with its own ideas and language features. Four programming paradigms are in this syllabus.
"Describe what is meant by an imperative (procedural) language" (two marks).A language in which the program is a sequence of instructions that are executed in order and that change the program's state; the programmer says how the task is done, using procedures, sequence, selection and iteration."Describe what is meant by a declarative language":the program states facts and rules (what is known and what is wanted) and the language's inference engine works out how to find the answer; the programmer does not give the sequence of steps.
Identify the paradigm from a code sample (a regular Paper 3 question): LDD 200, ADD #5, STO 201 is low-level (mnemonics, registers, memory addresses); FOR Count ← 1 TO 10 … NEXT Count with procedures and assignments is imperative; CLASS Dog … PRIVATE Name : STRING … PUBLIC PROCEDURE NEW(…) is object-oriented; type(lion, wild). and dangerous(X) IF type(X, wild) is declarative (logic). In the matching question: low-level pairs with "mnemonics that correspond directly to machine instructions", imperative with "a sequence of statements that change the state", OOP with "objects that combine attributes and methods", declarative with "facts and rules, with no order of execution given".
Low-level programming
Programming close to the hardware in machine code 机器码 or assembly language 汇编语言, where each instruction maps to what the CPU runs. It gives direct access to registers 寄存器 and memory addresses 内存地址, using different addressing modes 寻址方式 (immediate, direct, indirect, indexed and relative). It is very fast and compact, but architecture-specific, tedious, and hard to maintain. This is low-level 低级 programming, used for device drivers, firmware and bootloaders.
The five addressing modes. The syllabus asks for low-level code that uses each addressing mode (the instruction set is in Topic 4). The operand of a load instruction can be read five ways, and the exam gives you the memory contents and asks what the accumulator holds:
immediate (LDM #105): the operand is the value; ACC becomes 105.
direct (LDD 105): the operand is the address of the value; ACC becomes the contents of 105, here 27.
indirect (LDI 105): the operand is the address of an address; ACC becomes the contents of 27, here 91. Used for pointers and for data whose position is decided at run time.
indexed (LDX 105): the address is the operand plus the index register IX; with IX = 2, ACC becomes the contents of 107. Used to step through an array by incrementing IX.
relative (JMR +65): the target is an offset from the address of the current instruction, which makes the code relocatable.
Worked example. Memory: 105 holds 27, 106 holds 64, 200 holds 0. Write code to add the contents of 105 and 106, store the result in 200 and output it. LDD 105 (ACC = 27), ADD 106 (ACC = 91), STO 200, OUT. To double the value in 105 instead: LDD 105, ADD 105, STO 105. State the register contents after each line when asked to trace.
Imperative (procedural) programming
In imperative programming 命令式编程 the programmer writes a sequence of commands that change the program's state — assignments, conditionals, loops, function calls. Variables 变量 hold state; statements change it; code is organised into procedures and functions (also called structured or structural programming). This is the style of Topics 9 and 11 (Python, C). Strong when the algorithm has clear sequential steps.
Object-oriented programming (OOP)
In object-oriented programming 面向对象编程 programs are built from objects 对象 — units combining data (attributes 属性) and operations (methods 方法). Objects are instances 实例 of classes 类. The four pillars:
encapsulation 封装 — an object's data is hidden behind its methods; outside code uses the public methods only, not the data directly. This protects the object and lets its internals change without breaking callers. For example, a BankAccount hides its balance; you change it only through deposit() and withdraw(), which can enforce a rule like "never go below zero".
inheritance 继承 — a subclass 子类 specialises a superclass 父类, inheriting its attributes and methods and adding or overriding 重写 them. Models "is-a" ("a Manager is an Employee").
polymorphism 多态 — different objects respond to the same method call differently; the caller need not know the exact type. Every Shape has Area(), and a Circle and a Rectangle each implement it their own way.
abstraction 抽象 — show a simple interface and hide the implementation.
Other terms:
a constructor 构造函数 is a special method run when an object is created, to set up its attributes.
getters and setters read and write an object's attributes (its properties) through methods.
aggregation 聚合 and containment 包含 build an object from other objects (a "has-a" relationship).
OOP is used for large systems, GUIs, simulations and games.
OOP as the examiner marks it
Definitions.Class: a template (blueprint) that defines the attributes and methods of the objects of that type. Object: an instance of a class, created from it, with its own values for the attributes ("an occurrence of an object" is the exam's phrase for an instance). Attribute (property): a data item belonging to a class. Method: a procedure or function belonging to a class that acts on its attributes. Encapsulation: combining the attributes and methods in one class and restricting external access to the data: the attributes are private and can only be read or changed through public methods. Inheritance: a subclass acquires the attributes and methods of its parent (super) class and can add its own or override them. Polymorphism: methods with the same name that behave differently in different classes; typically a subclass redefines a method of its parent, and the right version runs for each object. Containment: a class has an object of another class as an attribute (a car has an engine). "Identify the feature that restricts external access to the data" is encapsulation; "the term for an occurrence of an object" is instance.
"Outline the structure of a class" (three marks): attributes (properties) that hold the object's data, usually declared private; methods (procedures and functions) that act on those attributes, usually public; and a constructor, a method that runs when an object is created to initialise the attributes. "Give three benefits of OOP": code is reused through inheritance; data is protected by encapsulation, so it can only be changed by the class's own methods; a large program is split into classes that are written and tested independently, so it is easier to maintain and extend; classes model real-world entities, so the design is easier to understand; polymorphism lets the same call work for different objects.
The class in pseudocode, as Paper 3 sets it:
An object is created with MyCar ← NEW Car("AB12 CDE", 2020) and used with MyCar.AddMileage(150) and OUTPUT MyCar.GetMileage(). A subclass reuses the parent's constructor through SUPER:
The same class in Python, as Paper 4 expects it: attributes are made private with a double underscore, the constructor is __init__, and a subclass names its parent in brackets and calls super().__init__(…):
In Java the same ideas are private/public fields, a constructor with the class's name, extends and super(…); in VB.NET Private/Public, Sub New, Inherits and MyBase.New. A polymorphic method is written in the parent and overridden in the child with the same name; a call through a parent-type variable runs the child's version.
Data structures as objects. Paper 4 builds a stack, linked list or binary tree from a Node class whose attributes are the data and one or two references to other nodes; a Tree (or LinkedList) class holds the root (or start) and the methods.
A find method walks the same path and returns TRUE when Current.Data = Target, FALSE when it reaches NULL; an in-order output method is recursive: output the left subtree, the node, then the right subtree. For a linked list the node has one reference, Next, and the list class holds Start; for a stack built from a list, push and pop both work at Start.
Worked example. A game has characters. Each has a name, health (starting at 100) and a position given by X and Y. Write a class Character with a constructor and a method Move(DX, DY); then a subclass Wizard that adds Mana (starting at 50) and a method CastSpell() that takes 10 mana and returns TRUE if there was enough.
The marks are for private attributes, a constructor that sets every attribute, the inheritance line, the call to the parent's constructor, and a method that uses and changes the object's own data. When the question asks for a class diagram, draw a box in three parts (name; attributes with - for private; methods with + for public) and join a subclass to its parent with an arrow pointing at the parent.
Declarative programming
In declarative programming 声明式编程 you say what to compute, not how — the runtime works out the steps. Two kinds:
functional programming 函数式编程 — built from pure functions 纯函数 (no side effects 副作用; same input always gives the same output) composed together. Examples: Haskell, Lisp.
logic programming 逻辑编程 — state facts and rules; the engine answers a goal (query) by inference. Example: Prolog.
A familiar declarative example is SQL 结构化查询语言: SELECT * FROM Customer WHERE Country = 'UK' says what you want, not how to walk the records.
Facts, rules and goals are what the exam tests in the declarative paradigm. Given these facts 事实 (statements that are true) and a rule 规则 (a conclusion that holds when its conditions hold):
"Write the result of the goal type(X, wild)":X = leopard, X = lion. The engine matches the goal against each fact in turn; every match is a solution, and a capital letter is a variable that the match fills in. "Write a fact to show that a cheetah is wild":type(cheetah, wild)."Explain what line 07 does": it defines a rule with the conclusion dangerous(X), which is true for any X that is both wild and large, so dangerous(A) returns A = leopard, A = lion. "Write a rule: a feature F may be available for a body style B if F is a feature and B is a body style and F is not unavailable for B":may_be_available(F, B) IF feature(F) AND body_style(B) AND NOT unavailable(F, B). Copy the exact predicate names and argument order used in the question's facts; a new fact ends with a full stop, and a rule's conditions are joined with AND.
Comparing paradigms
Paradigm
Strength
Typical languages
Low-level
maximum control, speed
assembly
Imperative
direct, intuitive
C, Python
Object-oriented
modular, models entities
Java, C#, Python
Functional
clear, no side effects
Haskell, F#
Logic
inference, rules
Prolog
Database
data queries
SQL
Modern languages often mix paradigms — Python supports all of procedural, OOP and functional. The right one depends on the problem.
עברית
פרדיגמת תכנות היא סגנון תכנות — דרך למבצע תוכניות, עם רעיונות ותכונות שפה משלה. ארבע פרדיגמות תכנות מופיעות במסלול לימודים זה.
"תאר מה נשמע בשפה אימפרטיבית (פרוצדורלית) (שתי נקודות)." שפה שבה התוכנית היא רצף של הוראות המבוצעות בסדר ומשנות את מצב התוכנית; המתכנן אומר איך ביצוע המשימה, באמצעות פרוצדורות, רצף, בחירה ואיטרציה. "תאר מה נשמע בשפה דקלרטטיבית:" התוכנית מציגה עובדות וחוקים (מה ידוע ומה רצוי) וה-מנוע מסקנות של השפה מחשב כיצד למצוא את התשובה; המתכנן אינו נותן את רצף השלבים.
זהה את הפרדיגמה מדוגמת קוד (שאלה רגילה בבחין 3): LDD 200, ADD #5, STO 201 הם רמת-תחתונה (מונימוןिकס, רשומות, כתובות זיכרון); FOR Count ← 1 TO 10 … NEXT Count עם פרוצדורות והטלות הוא אימפרטיבי; CLASS Dog … PRIVATE Name : STRING … PUBLIC PROCEDURE NEW(…) הוא אובייקטי-ממוקד; type(lion, wild). ו-dangerous(X) IF type(X, wild) הם דקלרטיביים (לוגיקה). בשאלת ההתאמה: רמת-תחתונה מותאמת ל"מונימוןיקס המתאימים ישירות להוראות מכונה", אימפרטיבי ל"רצף של הוראות המשנות את המצב", OOP ל"אובייקטים המשלבים מאפיינים ומתודות", דקלרטיבי ל"עובדות וחוקים, ללא סדר ביצוע נתון".
ארבע פרדיגמות: רמת-תחתונה, אימפרטיבית, אובייקטי-ממוקדת ודקלרטיבית
תכנות רמת-תחתונה
תכנות קרוב ל-hardware ב-קוד מכונה או שפת אסמבלר, שבו כל הוראה מקושרת למה שמעבד הבינה (CPU) מבצע. היא נותנת גישה ישירה לרשומות ולכתובות זיכרון, באמצעות מצבי עיבוד שונים (מיידית, ישירה, עקיפה, אינדקסית ויחסית). היא מהירה מאוד וצפופה, אך ספציפית לארכיטקטורה, עייפה וקשה לתחזוקה. זו תכנות רמת-תחתונה, המשמש לדרייברים, פירמוויר ו-Bootloaders.
חמישת מצבי העיבוד. המסלול דורש קוד רמת-תחתונה המשמש כל מצב עיבוד (סט ההוראות מופיע בנושא 4). האופרנד בהוראת טעינה יכול לקרוא חמישה דרכים, ובמבחן נותנים לך את תוכן הזיכרון ושואלים מה האקumulat holds:
אותו אופרנד, 105, קוראים חמישה דרכים: כערך, ככתובת, ככתובת של כתובת, ככתובת פלוס רשום האינדקס, וכהסחה מההוראה הנוכחית
מיידית (LDM #105): האופרנד הוא הערך; ACC הופך ל-105.
ישירה (LDD 105): האופרנד הוא הכתובת של הערך; ACC הופך לתוכן של 105, כאן 27.
עקיף (LDI 105): המפעיל הוא כתובת של כתובת; ACC הופך לתוכן של 27, כאן 91. משמש למצביעים ולנתונים שאת מיקומם קובעים בזמן הרצה.
מדורג (LDX 105): הכתוב היא המפעיל בנוסף לרשום האינדקס IX; כאשר IX = 2, ACC הופך לתוכן של 107. משמש לעבור על מערך על ידי הגדלת ערך IX.
יחסי (JMR +65): היעד הוא הזזה מהכתוב של ההוראה הנוכחית, מה שמאפשר תנועתיות לקוד.
דוגמה פותרת. זיכרון: 105 מכיל 27, 106 מכיל 64, 200 מכיל 0. כתוב קוד כדי להוסיף את תוכני 105 ו-106, לאחסן את התוצאה ב-200 ולהציג אותה. LDD 105 (ACC = 27), ADD 106 (ACC = 91), STO 200, OUT. כדי להכפיל פי שניים את הערך ב-105 במקום זאת: LDD 105, ADD 105, STO 105. ציין את תוכני הרשמים לאחר כל שורה כשנדרש לעקוב אחר הביצועים.
תכנות אימפרטיבי (פרוצדורלי)
בתוך תכנות אימפרטיבי, המתכנן כותב רצף של פקודות המשנות את מצב התוכנה — הקצאות, תנאים, לולאות, קריאות פונקציה. משתנים אחסנים מצב; פקודות משנות אותו; הקוד מאורגן בתוך פרוצדורות ופונקציות (נקרא גם תכנות מבני). זהו הסגנון של נושאים 9 ו-11 (Python, C). חזק כאשר לאלגוריתם יש שלבים רצופים ברורים.
תכנות ממוקד-אובייקטים (OOP)
בתוך תכנות ממוקד-אובייקטים, תוכניות נבנות מתוך אובייקטים — יחידות המשלבות נתונים (מאפיינים) ופעולות (שיטות). אובייקטים הם דגימות של מחלקות. הארבעת העמודים:
אינקפסולציה — נתוני האובייקט מוסתרים מאחורי השיטות שלו; קוד חיצוני משתמש רק בשיטות הפומביות, ולא בנתונים ישירות. הדבר מגן על האובייקט ומאפשר שינויים בפנים בלי לשבור את הצורכים. לדוגמה, BankAccount מסתיר את ה-balance שלו; אתה משנה אותו רק דרך deposit() וwithdraw(), שיכולות להטיל חוק כמו "לעולם לא לרדת מתחת לאפס".
ירישה — תת-מחלקה מתמחה בעל-מחלקה, יורשת ממנה מאפיינים ושיטות ומוסיפה או מתבטלת עליהן. מדגמית יחס "הוא-" ("מנהל הוא עובד").
פולימורפיזם — אובייקטים שונים מגיבים לאותה קריאת שיטה בצורה שונה; לצורך הקריאה אין צורך לדעת את סוג המדויק. כל Shape בעל Area(), ו-Circle ו-Rectangle מיישמים אותו כל אחד בדרכו השלה.
ה abstraction — להציג ממשק פשוט ולהסתיר את היישום.
מונחים אחרים:
בונה הוא שיטה מיוחדת הנערכת כאשר אובייקט נוצר, כדי לקבוע את מאפייניו.
קבלנים ומגדירים קוראים וכותבים מאפיינים של אובייקט (ה-מאפיינים שלו) דרך שיטות.
אגרגציה והכלאה בונים אובייקט מאובייקטים אחרים (יחס "יש-לו-").
תכנות ממוקד-אובייקטים משמש למערכות גדולות, ממשקים גרפיים, סימולציות ומשחקים.
פולימורפיזם: אותה קריאת שיטה מפעילה את הקוד של כל אובייקט,
תרשים מחלקה לצורת: מאפיינים פרטיים ומתודות ציבוריותיורשות: נגד-זמן וחלף זמן הן מחלקות נגד של עובדאקספונסציה: נתוני החפץ הם פרטיים, מושגים רק דרך המתודות הציבוריות שלו
OOP כפי שהבוחן מסמן אותו
הגדרות.מחלקה:תבנית (מפת קונסטרוקציה) שמגדירה את המאפיינים והמתודות של חפצים מסוג זה. חפץ:אינסטנציה של מחלקה, שנוצרה ממנה, עם ערכים משלו למאפיינים ("תרחיש של חפץ" הוא הביטוי בבחינה לאינסטנציה). מאפיין (מאפיין): פריט נתונים השייך למחלקה. מתודה: סעיף או פונקציה השייכים למחלקה הפועלים על המאפיינים שלה. אקספונסציה: מיזוג המאפיינים והמתודות במחלקה אחת והגבלת גישה חיצונית לנתונים: המאפיינים הם פרטיים וניתן לקרוא אותם או לשנותם רק דרך מתודות ציבוריות. יורשות: מחלקת נכד רוכשת את המאפיינים והמתודות של המחלקה ההורה (העליונה) ויכולה להוסיף את משלה או להחליף אותם. פולימורפיזם: מתודות עם אותו שם הפועלות באופן שונה במחלקות שונות; לרוב מחלקת נכד מגדירה מחדש מתודה של ההורה, וגרסה הנכונה פועלת לכל חפץ. הכללה (היכלות): למחלקה יש חפץ של מחלקה אחרת כמאפיין (רכב יש לו מנוע). "זהה את התכונה שמגבילה גישה חיצונית לנתונים" היא אקספונסציה; "המונח לתרחיש של חפץ" הוא אינסטנציה.
"סקיצה את מבנה המחלקה (שלוש נקודות):" מאפיינים (מאפיינים) המחזיקים את הנתונים של החפץ, בדרך כלל מוגדרים פרטיים; מתודות (סעיפים ופונקציות) הפועלות על מאפיינים אלו, בדרך כלל ציבוריות; ובונה, מתודה הפועלת כאשר חפץ נוצר כדי להתחיל את המאפיינים. "תן שלושה יתרונות של OOP:" הקוד מוחזר דרך יורשות; הנתונים מוגנים על ידי אקספונסציה, כך שניתן לשנותם רק על ידי מתודות המחלקה עצמה; תוכנית גדולה מחולקת למחלקות שנכתבות ונבדקות בנפרד, כך שקל יותר לתחזק ולהרחיב; מחלקות מדמות עולם אמיתי, כך שהעיצוב קל יותר להבנה; פולימורפיזם מאפשר לקריאה אותה לפעול עבור חפצים שונים.
המחלקה בפסאודוקוד, כפי שהמסמך 3 קובע זאת:
CLASS Car
PRIVATE Registration : STRING
PRIVATE Year : INTEGER
PRIVATE Mileage : INTEGER
PUBLIC PROCEDURE NEW(NewReg : STRING, NewYear : INTEGER)
Registration ← NewReg
Year ← NewYear
Mileage ← 0
ENDPROCEDURE
PUBLIC FUNCTION GetMileage() RETURNS INTEGER
RETURN Mileage
ENDFUNCTION
PUBLIC PROCEDURE AddMileage(Extra : INTEGER)
Mileage ← Mileage + Extra
ENDPROCEDURE
ENDCLASS
חפץ נוצר עם MyCar ← NEW Car("AB12 CDE", 2020) ומשמש עם MyCar.AddMileage(150) וOUTPUT MyCar.GetMileage(). מחלקת נכד משתמשת בשוב בבונה ההורה דרך SUPER:
CLASS ElectricCar INHERITS Car
PRIVATE BatteryCapacity : REAL
PUBLIC PROCEDURE NEW(NewReg : STRING, NewYear : INTEGER, NewCapacity : REAL)
SUPER.NEW(NewReg, NewYear)
BatteryCapacity ← NewCapacity
ENDPROCEDURE
ENDCLASS
אותה מחלקה בפיתון, כמו Paper 4 מצפה אליה: מאפיינים הופכים לפרטיים עם שני קווים תחתונים, הבונה הוא __init__, ומחלקה נגזרת מציגה את ההורה בברכיים וקוראת לsuper().__init__(…):
ב-Java הרעיונות האלה הם private/public שדות, בונה עם שם המחלקה, extends וsuper(…); ב-VB.NET Private/Public, Sub New, Inherits וMyBase.New. מתודה פולימורפית נכתבת בהורה ומוחלפת בילד עם אותו שם; קריאה דרך משתנה מסוג הורה פועלת בגרסת הילד.
מבני נתונים כחפצים. המסמך 4 בונה ערימה, רשימה מקושרת או עץ בינארי מתוך מחלקתNode whose attributes are the data and one or two references to other nodes; a Tree (or LinkedList) class holds the root (or start) and the methods.
עץ בינארי שנבנה מחפצים: כל Node מחזיק Data плюсLeft וRight references, והTree מחזיק את השורש; הכנסה הולכת למטה בדרכי הייחוס
CLASS Node
PUBLIC Data : INTEGER
PUBLIC Left : Node // NULL when there is no child
PUBLIC Right : Node
PUBLIC PROCEDURE NEW(NewData : INTEGER)
Data ← NewData
Left ← NULL
Right ← NULL
ENDPROCEDURE
ENDCLASS
CLASS Tree
PRIVATE Root : Node
PUBLIC PROCEDURE Insert(NewData : INTEGER)
DECLARE NewNode, Current : Node
DECLARE Placed : BOOLEAN
NewNode ← NEW Node(NewData)
IF Root = NULL THEN
Root ← NewNode
ELSE
Current ← Root
Placed ← FALSE
WHILE NOT Placed
IF NewData < Current.Data THEN
IF Current.Left = NULL THEN
Current.Left ← NewNode
Placed ← TRUE
ELSE
Current ← Current.Left
ENDIF
ELSE
IF Current.Right = NULL THEN
Current.Right ← NewNode
Placed ← TRUE
ELSE
Current ← Current.Right
ENDIF
ENDIF
ENDWHILE
ENDIF
ENDPROCEDURE
ENDCLASS
מתודת חיפוש הולכת באותה דרך ומחזירה TRUE כאשר Current.Data = Target, FALSE כאשר היא מגיעה לNULL; מתודת הדפסה בסדר פנימי היא רקורסיבית: הדפס את העץ המשמאל, את הנוד, ואז את העץ הימני. עבור רשימה מקושרת לנוד יש ייחוס אחד, Next, ומחלקת הרשימה מחזיקה Start; עבור ערימה שנבנתה מרשימה, push ו-pop פועלים שתיהם בStart.
דוגמה פעולה. משחק יש לו דמויות. לכל אחת יש שם, בריאות (מתחילת 100) ומיקום הנתון על ידי X ו-Y. כתוב מחלקה Character עם בונה ומתודה Move(DX, DY); אז מחלקת נכד Wizard שמוסיפה Mana (מתחילת 50) ומתודה CastSpell() שנוטלת 10 מנה ומחזירה TRUE אם היה מספיק.
CLASS Character
PRIVATE Name : STRING
PRIVATE Health : INTEGER
PRIVATE X : INTEGER
PRIVATE Y : INTEGER
PUBLIC PROCEDURE NEW(NewName : STRING, StartX : INTEGER, StartY : INTEGER)
Name ← NewName
Health ← 100
X ← StartX
Y ← StartY
ENDPROCEDURE
PUBLIC PROCEDURE Move(DX : INTEGER, DY : INTEGER)
X ← X + DX
Y ← Y + DY
ENDPROCEDURE
ENDCLASS
CLASS Wizard INHERITS Character
PRIVATE Mana : INTEGER
PUBLIC PROCEDURE NEW(NewName : STRING, StartX : INTEGER, StartY : INTEGER)
SUPER.NEW(NewName, StartX, StartY)
Mana ← 50
ENDPROCEDURE
PUBLIC FUNCTION CastSpell() RETURNS BOOLEAN
IF Mana >= 10 THEN
Mana ← Mana - 10
RETURN TRUE
ELSE
RETURN FALSE
ENDIF
ENDFUNCTION
ENDCLASS
הנקודות הן עבור מאפיינים פרטיים, בונה שמגדיר כל מאפיין, קו היורשות, הקריאה לבונה ההורה, ומתודה שמשתמשת ומשנה את הנתונים של החפץ. כאשר השאלה מבקשת תרשים מחלקה, צייר תיבה בשלושה חלקים (שם; מאפיינים עם - לפרטיים; מתודות עם + לציבוריים) וחבר מחלקת נכד להורה עם חץ המצביע על ההורה.
תכנות הצהרתי
בתכנות הצהרתי אתה אומר מה לחשבון, לא איך — הזמן הרצפה עורך את השלבים. שני סוגים:
תכנות פונקציונלי — בונה מתוך פונקציות טהורות (ללא אפקטים משני; אותו קלט תמיד מניב אותה תוצאה) המורכבות זו מזו. דוגמאות: Haskell, Lisp.
תכנות לוגי — מציין עובדות וכללים; המנוע עונה על מטרה (שאלה) באמצעות היסק. דוגמה: Prolog.
דוגמה הכרזתית מוכרת היא SQL: SELECT * FROM Customer WHERE Country = 'UK' אומר מה אתה רוצה, ולא איך לעבור על הרשומות.
עובדות, כללים ומטרות הם מה שהמבחן בודק בפארדיגמה ההכרזתית. בהינתן עובדות אלו (הצהרות הנחשבות לאמת) וכלל (מסקנה התוקפת כאשר התנאים שלה מתקיימים):
"כתוב את תוצאת המטרה type(X, wild)":* X = leopard, X = lion. המנוע מתאים את המטרה לכל עובדה בתור; כל התאמה היא פתרון, ואות גדולה היא משתנה שההתאמה ממלאה. "כתוב עובדה שמראה שצ'يتا הוא wild":type(cheetah, wild)."הסבר מה ש做着 line 07 doing": היא מגדירה כלל עם מסקנה dangerous(X), שהיא נכונה לכל X שהוא גם wild וגם גדול, כך שdangerous(A) מחזיר A = leopard, A = lion. "כתוב כלל: מאפיין F עשוי להיות זמין לסגנון גוף B אם F הוא מאפיין וB הוא סגנון גוף וF אינו מוגדר כ-missing עבור B":may_be_available(F, B) IF feature(F) AND body_style(B) AND NOT unavailable(F, B). העתק את שמות הפרדיקטים והסדר בדילוגים המדויקים משמש העובדות בשאלה; עובדה חדשה מסתיימת בנקודה, ותנאי של כלל מחוברים עם AND.
השוואת פארדיגמות
פארדיגמה
יתרון
שפות נפוצות
רמת נמוכה
שליטה מקסימלית, מהירות
Assembly
אימפרטיבי
ישיר, אינטואיטיבי
C, Python
אובייקט-מונחה
מודולרי, מדמה אירועים
Java, C#, Python
פונקציונלי
ברור, ללא אפקטים משניים
Haskell, F#
לוגי
היסק, כללים
Prolog
מסדי נתונים
שאילתות נתונים
SQL
שפות מודרניות לעיתים קרובות משלבות פארדיגמות — Python תומכת בכל המסגרות של פרוצ'ורדור, OOP ופונקציונלית. הנכונה תלויה בבעיה.
Explore · חקור
Programming concept lab · מעבדת מושגי תכנות
Connect examples to the programming idea they show. · קשר בין הדוגמאות לבין הרעיון התכנותי שהן מדגימות.
Open (in read, write, append mode) and close a file Read a record from a file and write a record to a file Perform file-processing operations on serial, sequential, random files
Show understanding of an exception and the importance of exception handling
Know when it is appropriate to use exception handling Write program code to use exception handling
עברית
המועמדים צריכים להיות מסוגלים:
הערות והנחיות
כתוב קוד לבצע פעולות עיבוד קבצים
פתיחה (במצב קריאה, כתיבה, הוספה) וסגירת קובץ קריאת רישום מקובץ וכתיבת רישום לקוב ביצוע פעולות עיבוד קבצים על קבצים סריליים, סדרתיים, אקראיים
הצג הבנה של חריגה וחשיבות טיפול בחריגות
לדעת מתי נכון להשתמש בטיפול בחריגות כתיבת קוד תכנות לשימוש בטיפול בחריגות
Source: Cambridge International syllabus · מקור: הסיילבוס הבינלאומי של קמבריד'ג'
English
This extends the file 文件 handling from Topic 10, processing serial, sequential and random (direct-access) files. Pseudocode operations: OPENFILE name FOR READ | WRITE | APPEND (READ opens an existing file, WRITE creates/overwrites, APPEND adds to the end); READFILE name, line; WRITEFILE name, value; CLOSEFILE name; and EOF(name) which is TRUE at the end.
Read a whole file:
Search a file (stop when found):
Updating a file in place
Most languages can't edit a text file in place. Instead: open the original for READ and a temporary file for WRITE; for each line, write the new version if it should change, else the original; close both; then replace the original with the temp file. The same pattern handles deleting lines (skip them) and inserting lines.
Records and random-access files
Opening modes.READ: the file must exist and reading starts at the beginning. WRITE: a new file is created, and an existing file of that name is overwritten. APPEND: writing adds to the end of an existing file. Every file that is opened is closed with CLOSEFILE, and EOF(name) is TRUE when the last item has been read.
Three file organisations. In a serial file the records are in the order they were added; in a sequential file they are in key order; both are read from the start. A random file 随机文件 (direct-access file) stores each record at an address calculated from its key by a hashing 哈希 function, so one record is found without reading the others. Records are declared as a user-defined type:
The random-file operations in pseudocode are OPENFILE "Acc.dat" FOR RANDOM, SEEK "Acc.dat", Address (move the file pointer to that record), GETRECORD "Acc.dat", Rec (read the record there) and PUTRECORD "Acc.dat", Rec (write the record there). Finding a customer by account number, as Paper 3 sets it:
To store a record, hash its key, SEEK to the address and PUTRECORD, stepping on past any slot already occupied. Marks go to the hash, the SEEK before the GET or PUT, the comparison with the target, the handling of a collision, and closing the file.
Worked example.ActiveFile.dat holds AccountRecord records. Write pseudocode that copies every record whose Active field is FALSE to the end of ArchiveFile.dat.
Text files in Python (Paper 4): file = open("HighScore.txt", "r"), then for line in file: with line.strip() and line.split(",") to separate the fields, int(…) to convert a score, and file.close(); to write, open(name, "w") (or "a" to append) and file.write(str(score) + "\n"). A high-score table is read into a list of records, the new score inserted at its place, and the whole list written back. The examiner marks the open with the correct mode, a loop that reads every line, the conversion of text to numbers, and the close.
Pitfalls
Forgetting to close a file (data may be lost); opening for WRITE when you meant APPEND (overwrites everything); reading past EOF; hard-coded paths — a path like /Users/Admin/data.txt breaks on another machine, so use a relative constant such as DataFile = "./data/scores.txt".
עברית
זהו הרחבה של הטיפול בקובץ מנושא 10, ועיבוד קבצים סריאליים, רציף ואקראיים (גישה ישירה). פעולות פסאודוקוד: OPENFILE name FOR READ | WRITE | APPEND (READ פותח קובץ קיים, WRITE יוצר/עובר על כתיבה, APPEND מוסיף בסוף); READFILE name, line; WRITEFILE name, value; CLOSEFILE name; וEOF(name) שהוא TRUE בסוף.
קריאת קובץ שלם:
OPENFILE "names.txt" FOR READ
WHILE NOT EOF("names.txt") DO
READFILE "names.txt", thisName
OUTPUT thisName
ENDWHILE
CLOSEFILE "names.txt"
חיפוש בקובץ (עצור כשהתוצאה נמצאת):
found ← FALSE
OPENFILE "people.txt" FOR READ
WHILE NOT EOF("people.txt") AND NOT found DO
READFILE "people.txt", line
IF line = target THEN
found ← TRUE
ENDIF
ENDWHILE
CLOSEFILE "people.txt"
עדכון קובץ במיקום המקורי
רוב השפות אינן יכולות לערוך קובץ טקסט במיקום המקורי. במקום זאת: פתח את המקורי לקריאה וקובץ זמני לכתיבה; לכל שורה, כתוב את הגרסה החדשה אם צריך לשנות, אחרת את המקורית; סגור את שניהם; ואז החלף את המקורי בקובץ הזמני. אותו דגם מטפל גם במחיקת שורות (מעבר עליהן) והכנסת שורות.
*עדכון קובץ באופן מקומי: קריאת המקורי, כתיבת השינויים לקובץ זמני, והחלפת המקורי
רשומות וקבצי גישה אקראית
מצבי פתיחה.READ: הקובץ חייב להתקיים והקריאה מתחילה מהתחלה. WRITE: נוצר קובץ חדש, וקובץ קיים באותו שם מוחלף. APPEND: הכתיבה מוסיפה לסוף קובץ קיים. כל קובץ שנפתח נסגר בCLOSEFILE, וEOF(name) הוא TRUE כאשר הרכיב האחרון נקרא.
שלושה סוגי ארגוניזציה של קבצים. בקובץ סדרתי הרשומות הן בסדר הוספתן; בקובץ רצפי הן מסודרות לפי מפתח; שניהם נקראים מהתחלה. קובץ אקראי (קובץ גישה ישירה) מאחסן כל רשומה בכתובת המוחשבת מהמפתח שלה באמצעות פונקציית השחתה, כך שמציאת רשומה אחת מתבצעת ללא קריאת שאר הרשומות. רשומות מוגדרות כסוג מוגדר על ידי משתמש:
TYPE AccountRecord
DECLARE AccNo : INTEGER
DECLARE Name : STRING
DECLARE Balance : REAL
DECLARE Active : BOOLEAN
ENDTYPE
*מציאת רשומה אחת בקובץ אקראי: המפתח מושחת לכתובת, אינדיקס הקובץ מכוון ישירות לתא זה והרשומה נקראת; אין מגע עם רשומות אחרות
פעולות הקובץ האקראי בפסדוקוד הן OPENFILE "Acc.dat" FOR RANDOM, SEEK "Acc.dat", Address (הזזת אינדיקס הקובץ לרשומה זו), GETRECORD "Acc.dat", Rec (קריאת הרשומה שם) וPUTRECORD "Acc.dat", Rec (כתיבת הרשומה שם). מציאת לקוח לפי מספר חשבון, כפי שנקבע במבחן Paper 3:
DECLARE Rec : AccountRecord
DECLARE Target, Address : INTEGER
INPUT Target
Address ← Target MOD 1000 // the hashing function
OPENFILE "Acc.dat" FOR RANDOM
SEEK "Acc.dat", Address
GETRECORD "Acc.dat", Rec
WHILE Rec.AccNo <> Target AND Rec.AccNo <> 0 // 0 marks an empty slot
Address ← Address + 1 // a collision: try the next slot
SEEK "Acc.dat", Address
GETRECORD "Acc.dat", Rec
ENDWHILE
IF Rec.AccNo = Target THEN
OUTPUT Rec.Name, Rec.Balance
ELSE
OUTPUT "No such account"
ENDIF
CLOSEFILE "Acc.dat"
כדי לאחסן רשומה, יש להשתחת את המפתח שלה, ⟨SEEK⟩ לכתובת ולPUTRECORD, דורשים על פני כל תא שתפוס כבר. נקודות מוכנות להשחתה, ל-SEEK לפני ה-GET או PUT, להשוואה למטרה, לטיפול בהתנגשות, ולסגירת הקובץ.
דוגמה פתורה.ActiveFile.dat מכיל AccountRecord רשומות. כתוב פסאודוקוד שמעתיק כל רשומה שבה שדה Active הוא FALSE בסוף ArchiveFile.dat.
DECLARE Rec : AccountRecord
OPENFILE "ActiveFile.dat" FOR READ
OPENFILE "ArchiveFile.dat" FOR APPEND
WHILE NOT EOF("ActiveFile.dat")
READFILE "ActiveFile.dat", Rec
IF Rec.Active = FALSE THEN
WRITEFILE "ArchiveFile.dat", Rec
ENDIF
ENDWHILE
CLOSEFILE "ActiveFile.dat"
CLOSEFILE "ArchiveFile.dat"
קבצי טקסט ב-Python (Paper 4): file = open("HighScore.txt", "r"), ואז for line in file: עם line.strip() וline.split(",") להפרדת השדות, int(…) להמרת ציון, וfile.close(); לכתיבה, open(name, "w") (או "a" להוספה) וfile.write(str(score) + "\n"). טבלת הציונים הגבוהים נקראת לרשימת רשומות, הציון החדש מוזרק במקומו, והרשימה כולה נכתבת חזרה. המבקר מעריך את הפתיחה עם המצב הנכון, לולאה שקוראת כל שורה, ההמרה מטקסט למספרים, ואת הסגירה.
נקודות חולשה
שכחת סגירת קובץ (נתונים עשויים לאבד); פתיחה לכתיבה כאשר התכוונת להוספה (מוחקת הכל); קריאה מעבר לEOF; נתיבים קבועים — נתיב כמו /Users/Admin/data.txt יישבר במכונה אחרת, לכן השתמש בקבוע יחסי כמו DataFile = "./data/scores.txt".
Explore · חקור
File access route · מסלול גישה לקובץ
Follow a file from storage to program and back safely. · עקבו אחר קובץ מהאחסון לתוכנית וחזרה בבטחה.
An exception 异常 is an error or unexpected condition during execution — divide by zero, file not found, network failure, an array 数组 index out of range. Exception handling 异常处理 lets a program detect it and respond gracefully instead of crashing.
It matters because real programs face errors that cannot be prevented up front (files moved, networks down, bad input); without it, every operation needs its own IF check; and it separates the normal flow from the error handling, so the main path reads cleanly. For example, a file may be deleted by another user between your program checking it exists and actually opening it — you cannot prevent that, only handle the failure when it happens.
"Describe, with an example, what is meant by an exception" (two marks).An unexpected event or error that occurs during the execution of a program (at run time) and interrupts its normal flow; for example dividing by zero, opening a file that does not exist, converting non-numeric input to an integer, an array index out of range, or running out of memory."Identify two possible causes of exceptions" is answered from that list, plus "a device or network is not available" and "invalid data type entered".
"State the reasons for including exception handling" (three marks). To stop the program crashing (terminating unexpectedly); to output a meaningful message to the user rather than a system error; to allow the program to recover and continue, for example by asking for the input again, or to close files safely before it ends; and because some errors cannot be predicted when the program is written. "Describe how program termination due to an exception can be avoided": put the statements that might raise the exception inside a TRY block; write an EXCEPT (catch) block for that exception that handles it, for example by outputting a message, so that execution continues after the block instead of stopping. "Explain what is meant by exception handling": detecting an exception when it occurs and running code (the handler) that deals with it so that the program continues.
Pattern
The TRY block holds the code that might fail; the first matching EXCEPT block runs. Real languages also have a catch-all EXCEPT and a FINALLY block that runs whether or not an exception happened — useful for cleanup (closing files).
Raising an exception
A subroutine that detects an error can raise 抛出 an exception so the caller handles it:
Where to handle exceptions
Handle them close to the error if the response is simple (a message, a retry), or higher up the call stack 调用栈 if only the outer code knows what to do (a top-level GUI loop logs the error and shows a friendly dialog). Don't swallow exceptions silently — at least log them, or debugging becomes impossible.
Common exceptions: FileNotFound, IOError, DivisionByZero, IndexOutOfRange, InvalidArgument, NullReference, OutOfMemory. Wrapping each failing operation in a TRY with the right EXCEPT handlers gives a program that degrades gracefully instead of crashing.
Worked example (Paper 4). Write a function that reads whole numbers, one per line, from a file whose name is passed as a parameter and returns them in a list. It must not crash if the file does not exist or a line is not a whole number.
The try block holds the code that can fail (the open and the conversion); each except names one exception and does something useful; the function still returns a list, so the caller continues. In Java the same shape is try { … } catch (FileNotFoundException e) { … } catch (NumberFormatException e) { … }; in VB.NET Try … Catch ex As FileNotFoundException … End Try. Marks: the risky statements inside the try, the correct exception names, a message for each, and the program continuing afterwards; a catch-all except: gets the crash mark but not the "appropriate exception" mark.
Worked example. A text file of members needs one member's phone number changed. Why can the program not simply overwrite that line, and what is the pattern? A text file's lines are different lengths, and the file has no gaps to absorb a difference: a longer replacement would run into the next record, and a shorter one would leave part of the old line behind. So the pattern is to open the original for READ and a temporary file for WRITE, read every line in turn, writing the new version for the line that changes and the original line for all the others, close both, then replace the original with the temporary file. The same shape handles deleting (skip the line) and inserting (write the extra line). Note that every line gets written, not only the changed one - writing just the new record and losing the rest of the file is the classic slip.
עברית
חריגה היא שגיאה או מצב בלתי צפוי במהלך ביצוע — חלוקה באפס, קובץ לא נמצא, כשל ברשת, אינדקס מעבר לגבול. טיפול בחריגות מאפשר לתוכנית זיהוי אותו ולהגיב בצורה נכונה במקום להתמוטט.
זה חשוב כי תוכניות אמיתיות נתונות לשגיאות שלא ניתן למנוע מראש (קבצים הוזזו, רשתות לא פעילות, כניסה שגויה); בלי זה, לכל פעולה יש צורך בבדיקת IF נפרדת; והוא מפריד בין הזרימה הרגילה לבין טיפול בשגיאות, כך שהמסלול הראשי נשאר נקי. לדוגמה, קובץ עשוי להימחק על ידי משתמש אחר בין הבדיקה שלך שהוא קיים לבין הפתיחה האמיתית שלו — אי אפשר למנוע זאת, רק לטפל בכשל כאשר הוא קורה.
"תיאור, בדוגמה, מהו חריג" (שתי נקודות). אירוע או שגיאה בלתי צפויה שמתרחשת במהלך הביצוע של תוכנית ( בזמן הרצה) ומפסקת את הזרימה הרגילה שלה; לדוגמה חלוקה באפס, פתיחת קובץ שאינו קיים, המרת כניסה שאינה מספרית למספר שלם, אינדקס מעבר לגבול, או גמר זיכרון."זהה שתי סיבות אפשריות לחריגות" נענה מהרשימה הזו, בנוסף "התקן או רשת אינם זמינים" ו"סוג נתונים לא תקין הוזן".
"צין את הסיבות לכלולת טיפול בחריגות" (שלוש נקודות). כדי למנוע התמוטטות התוכנית (סיום בלתי צפוי); להוציא הודעה משמעותית למשתמש במקום שגיאת מערכת; לאפשר לתוכנית להתאושש ולהמשיך, לדוגמה על ידי בקשת הכניסה שוב, או לסגור קבצים בבטחה לפני הסיום; וכיוון שחלק מהשגיאות לא ניתן לחזות כאשר התוכנית נכתבת. "תיאור איך למנוע סיום תוכנית עקב חריגה": הנח את הפקודות שעשויות להרים חריגה בתוך בלוק TRY; כתוב בלוק EXCEPT (catch) עבור חריגה זו שמטפל בה, לדוגמה על ידי הוצאת הודעה, כך שהביצוע ימשיך לאחר הבלוק במקום לעצור. "הסבר מהו טיפול בחריגות": זיהוי חריגה כאשר היא מתרחשת וביצוע קוד (ה-handler) שמטפל בה כך שהתוכנית ממשיכה.
דגם
TRY
OPENFILE "data.txt" FOR READ
READFILE "data.txt", line
OUTPUT line
CLOSEFILE "data.txt"
EXCEPT FileNotFound
OUTPUT "Sorry, the file does not exist."
EXCEPT ReadError
OUTPUT "Sorry, error reading the file."
ENDTRY
הבלוק TRY מכיל את הקוד שעשוי להכשל; הבלוק EXCEPT המתאים הראשון נעשה. שפות אמיתיות גם כן כוללות catch-all EXCEPT ובלוק FINALLY שנעשה בין אם קרה חריגה ובין אם לא — שימושי לניקוי (סגירת קבצים).
*תהליך חריגות: חריגה קופצת ל-EXCEPT המתאים; FINALLY תמיד מתבצע לפני שהתוכנית ממשיכה
הרמת חריגה
תת-תוכנית המזהה שגיאה יכולה להרים חריגה כך שהקורא יטפל בה:
PROCEDURE Divide(a : INTEGER, b : INTEGER) RETURNS INTEGER
IF b = 0 THEN
RAISE DivideByZero
ENDIF
RETURN a DIV b
ENDPROCEDURE
היכן לטפל בחריגות
טפלו בהם קרוב לשגיאה אם התגובה פשוטה (הודעה, ניסיון חידוש), או גבוה יותר ב-שכבת הקריאה אם רק הקוד החיצוני יודע מה לעשות (למשל, לולאת GUI ברמה עליונה מדווחת על השגיאה ומציגה דיאלוג ידידותי). אל תבלעו חריגות בשקט — לפחות דווחו עליהן, או שתהיה בלתי אפשרית הדיבוג.
חריגות נפוצות: FileNotFound, IOError, DivisionByZero, IndexOutOfRange, InvalidArgument, NullReference, OutOfMemory. עטיפה של כל פעולה כושלת ב-TRY עם מטפלים מתאימים ל-EXCEPT מעניקה לתוכנית יכולת להתקלקל בצורה מסודרת במקום להתמוטט.
דוגמה פתירה (מסמך 4). כתבו פונקציה לקריאת מספרים שלמים, אחד בכל שורה, מקובץ whose שם עובר כפרמטר והחזרתם ברשימה. היא לא צריכה להתמוטט אם הקובץ אינו קיים או אם שורה אינה מכילה מספר שלם.
def read_scores(filename):
scores = []
try:
file = open(filename, "r")
for line in file:
scores.append(int(line))
file.close()
except FileNotFoundError:
print("The file", filename, "does not exist")
except ValueError:
print("A line in the file was not a whole number")
return scores
בלוק ה-try מכיל את הקוד שעלול לכשל (הפתיחה וההמרה); כל ⟨except⟩ מציין חריגה אחת ועושה משהו שימושי; הפונקציה עדיין מחזירה רשימה, כך שהקורא ממשיך. בג'אבה אותו מבנה הוא ⟨try { … } catch (FileNotFoundException e) { … } catch (NumberFormatException e) { … }⟩; ב-VB.NET הוא ⟨Try … Catch ex As FileNotFoundException … End Try⟩. ציונים: הפקודות הסיכוןיות בתוך ה-try, שמות החריגות הנכונות, הודעה לכל אחת, והתוכנית ממשיכה לאחר מכן; catch-all ⟨except:⟩ מקבל את ניקוד ההתמוטט אך לא את ניקוד "החריגה המתאימה".
דוגמה פתירה. קובץ טקסט של חברים זקוק לשינוי מספר טלפון של חבר אחד. מדוע התוכנית לא יכולה פשוט להחליף את השורה הזו, ומהי הדפוס? שורות בקובץ טקסט הן בעלות אורכים שונים, ולקובץ אין רווחים לספיגת ההבדל: החלפה ארוכה יותר תהרוס את הרקורד הבא, וחלוקה קצרה יותר תשאיר חלק משורה ישנה מאחור. לכן הדפוס הוא לפתוח את המקורי ל-קריאה וקובץ זמני ל-כתיבה, לקרוא כל שורה בתור, לכתוב את הגרסה החדשה עבור השורה המשתנה ואת השורה המקורית עבור שאר השורות, לסגור את שניהם, ולאז להחליף את המקורי בקובץ הזמני. אותו מבנה מטפל גם במחיקה (דלגו על השורה) והכנסה (כתבו שורה נוספת). שימו לב שכל שורה כותבת, לא רק זו שהשתנתה - כתיבת רק הרקורד החדש ואובדן שאר הקובץ היא טעות קלאסית.
Explore · חקור
How exception handling flows · כיצד זרימת טיפול בחריגות מתנהלת
Step through what happens when code fails. The exception jumps out of the normal flow to a handler, FINALLY cleans up either way, and the program carries on instead of crashing. · עבור שלב-בשלב על מה שקורה כשהקוד נכשל. החריגה קופצת מחוץ לזרימה הרגילה למטפל, FINALLY מבצע ניקוי בכל מקרה, והתוכנית ממשיכה במקום להתמוטט.
Definitions the examiner accepts · הגדרות מקובלות בקורס
English
A definition question is marked against fixed wording. Learn these exactly, and give one answer only.
Term
Definition
programming paradigm
a style or way of programming, with its own way of structuring a program
imperative language
the program is a sequence of statements that change the program's state; the programmer says how the task is done
declarative language
the program states facts and rules and the inference engine works out how to find the answer
class
a template defining the attributes and methods of the objects of that type
object (instance)
an occurrence of a class, with its own values for the attributes
attribute
a data item that belongs to a class
method
a procedure or function that belongs to a class and acts on its attributes
encapsulation
keeping the attributes and methods together in a class and restricting external access to the data, so that it is changed only through public methods
inheritance
a subclass acquires the attributes and methods of its parent class and can add or override them
polymorphism
methods with the same name that behave differently for different classes
constructor
a method that runs when an object is created and initialises its attributes
containment
a class has an object of another class as one of its attributes
fact
a statement in a declarative program that is true
rule
a conclusion that holds when its conditions are true
serial, sequential, random file
records in the order added; records in key order; each record at an address calculated from its key
exception
an unexpected error or event during execution that interrupts the normal flow
exception handling
detecting an exception when it occurs and running code that deals with it so that the program continues
עברית
שאלת הגדרה מוקדמת לפי טקסט קבוע. לימודן במדויק, ותן תשובה אחת בלבד.
מונח
הגדרה
פרדיגמת תכנות
סגנון או דרך לתכנות, עם דרכה המבנית עצמאית לתכנית
שפת פקודות
התוכנית היא רצף של פקודות המשנות את מצב התוכנית; המתכנן אומר כיצד המשימה מבוצעת
שפת הצהרות
התוכנית מציגה עובדות וכללים והמנגנון האינפראנטיבלי מחשב כיצד למצוא את התשובה
מחלקה
תבנית המגדירה את האטריבוטים והשיטות של האובייקטים מסוג זה
אובייקט (אינסטנס)
התרחשות של מחלקה, עם ערכים משלו לאטריבוטים
אטריבוט
פריט נתונים השייך למחלקה
שיטה
פרוצדורה או פונקציה השייכות למחלקה ופעילות על האטריבוטים שלה
encapsulation
שמירה על אטריבוטים ושיטות יחד במחלקה והגבלת גישה חיצונית לנתונים, כך שהם משונים רק דרך שימות ציבוריות
inheritance
מחלקת בת רוכשת את האטריבוטים והשיטות של המחלקה ההורה שלה ויכולת להוסיף או לשנות אותן
polymorphism
שיטות באותו שם שנ行为 שונות למחלקות שונות
בונה
שיטה הנפעלת כאשר נוצר אובייקט ומאפיינה את מאפייןיו
התכללות
מחלקה מכילה אובייקט של מחלקה אחרת כמאפיין אחד שלה
עובדה
משפט בתוכנית הכרזתית שהנחה
כלל
מסקנה המתקבלת כאשר תנאיה מתקיימים
קובץ סדרתי, רצף-אורידנטי, מקרי
רשומות בסדר הנוסף; רשומות לפי סדר המקוד; כל רשומה כתובת המוחשפת מהמקודה שלה
חריגה
שגיאה או אירוע בלתי צפוי במהלך הביצוע המפריעים לזרימה הרגילה
טיפול בחריגות
זיהוי חריגה בזמן התרחשותה והפעלת קוד העוסק בה כדי לאפשר להמשך הפעולה
20.2
Exam tips · טיפים לבחינות
English
Paradigms: know the one-line description of each and be ready to name the paradigm from a code sample; low-level questions want the five addressing modes and what the accumulator receives.
OOP definitions come up every session: class, object, attribute, method, encapsulation, inheritance, polymorphism, constructor. Write a class in pseudocode with PRIVATE attributes, a PUBLIC NEW and getters; a subclass with INHERITS and SUPER.NEW.
Declarative: a goal with a variable returns every matching fact; a rule is a conclusion IF conditions joined with AND; copy the question's predicate names exactly.
Files: the three modes and what each does to an existing file; READFILE in a WHILE NOT EOF loop; random files use a hash, SEEK, GETRECORD and PUTRECORD, with a step-on for collisions.
Exceptions: definition with an example, three reasons for handling them, and TRY with a named EXCEPT that lets the program continue.
Common mistakes
Describing a declarative program as "a sequence of steps that gives the answer"; it states what is true and what is wanted, not how.
Confusing an object with a class, or an instance with an attribute; the question "an occurrence of an object" wants instance.
Declaring the attributes PUBLIC, or reaching them from outside the class instead of through a getter, which loses the encapsulation marks.
A subclass constructor that sets the parent's attributes directly instead of calling SUPER.NEW.
Explaining polymorphism as "many objects"; it is the same method name behaving differently for different classes.
Opening a file FOR WRITE to add a record, which destroys the existing contents; use APPEND.
Reading a random file from the start; SEEK to the hashed address first.
Putting the exception handler around code that cannot fail, or catching everything with no message, or describing exception handling as "checking the input with IF".
עברית
פרדיגמות: יש לדעת את ההגדרה בקו אחד לכל אחת ולהיות מוכן לזהות את הפרדיגמה מדוגמת קוד; שאלות ברמת פרטים דורשות את חמישת מצבי הכישרוף ואת מה שמקבל האקוםולטור.
הגדרות OOP מופיעות בכל מועד: מחלקה, אובייקט, מאפיין, שיטה, עטיפה, ירשה, פולימוRFism, בונה. יש לכתוב מחלקה בפסאודוקוד עם מאפיין PRVATE, NEW ציבורי וגטרים; מחלקת-בת עם INHERITS ו-SUPER.NEW.
הכרזתית: מטרה עם משתנה מחזירה כל עובדה תואמת; כלל הוא מסקנה אם תנאים המחוברים ב-AND; העתק את שמות הפריקטים בשאלה בדיוק.
קבצים: שלושת המצבים ומה שעושים כל אחד לקוביים קיים; READFILE בתוך WHILE NOT EOF; קבצי מקרי משתמשים ב-HASH, SEEK, GETRECORD ו-PUTRECORD, עם סיכון התנגשות.
חריגות: הגדרה עם דוגמה, שלוש סיבות לטיפול בהם, ו-TRY עם EXCEPT שמחזיר שם המאפשר למשימה להמשיך.
טעויות נפוצות
תיאור תוכנית הכרזתית כ"רצף של שלבים המניחים את התשובה"; היא מציגה מה נכון ומה נרצה, ולא איך.
בלבול בין אובייקט לבין מחלקה, או בין instance לבין מאפיין; השאלה "התרחשות של אובייקט" דורשת instance.
הצהרת מאפיין כpublIC, או גישה אליהם מחוץ למחלקה במקום דרך getter, מה שמפחית את סימני העטיפה.
בונה מחלקת-בת המגדיר את מאפיין ההורה ישירות במקום לקרוא ל-SUPER.NEW.
הסבר פולימוRFism כ"מספר אובייקטים"; זהו אותו שם שיטה התנהגות שונה עבור מחלקות שונות.
פתיחת קובץ FOR WRITE להוספת רשומה, מה שמוחק את התוכן הקיים; יש להשתמש ב-APPEND.
קריאת קובץ מקרי מהתחלה; SEEK לכתובת המוחשפת תחילה.
סגירת בלוק טיפול בחריגה סביב קוד שאינו יכול לכשל, או caught כל חריגה ללא הודעה, או תיאור טיפול בחריגות כ"בדיקת קלט עם IF".
Interactive lessons on this topic · שיעורים אינטראקטיביים בנושא זה
Work through it step by step, with instant-check exercises. · לעבור על הדברים צעד אחר צעד, עם תרגילים לבדיקה מיידית.
Pick one and the site follows you — notes, papers, videos and practice all open on it. · בחרו נושא אחד והאתר יעקוב אחריו — הערות, מסמכים, וידאו ותרגולים פתוחים בו.
Type to search notes, lessons, code, vocabulary and past-paper questions across every subject. · הקלד כדי לחפש הערות, שיעורים, קוד, אוצר מילים ושאלות מבחנים בכל הנושאים.
פולימורפיזם: אותה קריאת שיטה מפעילה את הקוד של כל אובייקט,
*מציאת רשומה אחת בקובץ אקראי: המפתח מושחת לכתובת, אינדיקס הקובץ מכוון ישירות לתא זה והרשומה נקראת; אין מגע עם רשומות אחרות