추가 프로그래밍

프로그래밍 패러다임은 프로그래밍의 스타일로서, 자체적인 개념과 언어 기능을 갖춘 프로그램을 구조화하는 방식임. 이 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.

코드 샘플에서 패러다임을 식별하기 (일반 Paper 3 문제): LDD 200, ADD #5, STO 201는 저수준 (mnemonics, 레지스터, 메모리 주소); procedures와 assignments가 포함된 FOR Count ← 1 TO 10 … NEXT Count은 명령형; CLASS Dog … PRIVATE Name : STRING … PUBLIC PROCEDURE NEW(…)은 객체 지향적; type(lion, wild).과 dangerous(X) IF type(X, wild)은 선언형 (논리). 매칭 문제에서: 저수준은 "기계 명령어에 직접 대응하는 mnemonics", 명령형은 "상태를 변경하는 명문의 나열", OOP는 "속성과 메서드를 결합한 객체", 선언형은 "실행 순서가 명시되지 않은 사실과 규칙"과 짝을 이룹니다.

저수준 프로그래밍

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.

** 다섯 가지 주소 지정 방식.** syllabus는 각 주소 지정 방식/addressing mode를 사용하는 저수준 코드를 요구함 (지령 세트는 Topic 4 참조). load 지령의 피연산자는 5가지 방식으로 읽힐 수 있으며, 시험에서는 메모리 내용을 제공하여 어큐뮬레이터(accumulator)에 어떤 값이 저장되는지를 묻음:

• immediate (LDM #105): 피연산자가 값 그 자체임; ACC는 105가 됨.
• direct (LDD 105): 피연산자가 값의 주소임; ACC는 105의 내용(여기서는 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.
• 인덱스 방식 (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. 추적을 요청할 경우 각 줄 후 레지스터의 내용을 명시하십시오.

Imperative (절차적) 프로그래밍

imperative 프로그래밍에서 프로그래머는 프로그램의 상태를 변경하는 명령의 연속을 작성함—할당문, 조건문, 루프, 함수 호출 등. 변수는 상태를 유지하고, 문장은 이를 변경하며, 코드는 procedures와 functions(또는 structured 또는 structural 프로그래밍이라 Called)로 조직됨. 이는 Topic 9와 11의 스타일(Python, C). 알고리즘에 명확한 순차적 단계가 있을 때 강점임.

Object-Oriented Programming (OOP)

object-oriented 프로그래밍에서 프로그램은 objects—data(속성/attributes)와 operations(메소드/methods)를 결합한 단위들로부터 구성됨. Objects는 classes의 인스턴스(instance). 네 개의 기둥(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—子类(subclass) specialization a superclass, inherits its attributes and methods and adds or overrides them. Models "is-a" (e.g., "a Manager is an Employee").
• 폴리모피즘 — 서로 다른 객체가 동일한 메서드 호출에 대해 다르게 반응하며, 호출자는 정확한 타입을 알 필요 없습니다. 모든 Shape은 Area()을 가지며, Circle과 Rectangle은 각각 자체적으로 이를 구현합니다.
• 추상화 — 간단한 인터페이스를 제시하고 구현을 숨김.

다른 용어:

• 컨스트럭터는 객체가 생성될 때 실행되는 특수 메서드로, 속성을 설정하기 위해 사용됩니다.
• 게터와 세터는 메서드를 통해 객체의 속성(그의 프로퍼티)을 읽거나 쓰는 기능을 합니다.
• aggregation 및 containment은 다른 객체들을 결합하여 하나의 객체를 생성합니다("has-a" 관계).

OOP는 대형 시스템, GUI, 시뮬레이션 및 게임에 사용됩니다.

*인캡슐링: 객체의 데이터는 -private이며, -public 메서드를 통해만 접근 가능

OOP를 평가자가 점수 부여하는 방식

정의. Class: 해당 유형의 객체의 속성과 메서드를 정의하는 템플릿(블루프린트). Object: class의 인스턴스로, 그로부터 생성되며 속성에 대한 고유 값을 가짐("an occurrence of an object"는 인스턴스에 대한 시험 용어임). Attribute (property): class에 속하는 데이터 항목. Method: class에 속하여 속성에 작용하는 절차 또는 함수. Encapsulation: 속성과 메서드를 하나의 class에 결합하고 데이터에 대한 외부 접근을 제한: 속성은 private이며 public 메서드를 통해만 읽거나 변경 가능. Inheritance: 자급 class가 부모(초급) class의 속성과 메서드를 계승하며 자체 속성/메서드를 추가하거나 기존 것을 오버라이드 가능. Polymorphism: 같은 이름을 가진 메서드가 다른 class에서 다르게 동작; 일반적으로 자급 class가 부모의 메서드를 재정의하며 각 객체에 맞는 올바른 버전이 실행됨. Containment: 한 class가 다른 class의 객체를 속성으로 가짐(예: 자동차가 엔진을 가짐). "데이터에 대한 외부 접근을 제한하는 기능"은 encapsulation; "객체의 발생을 의미하는 용어"는 instance임.

"클래스의 구조를 설명하시오" (3점): 객체의 데이터를 저장하는 속성(프로퍼티)은 보통 private으로 선언됨; 이 속성에 작용하는 메서드(절차 및 함수)는 보통 public임; constructor는 객체가 생성될 때 실행되어 속성을 초기화하는 메서드임. "OOP의 세 가지 장점": code는 inheritance를 통해 재사용됨; data는 encapsulation에 의해 보호되어 class 자체의 메서드만이 변경 가능함; 대형 프로그램은 classes로 분리되어 독립적으로 작성 및 테스트되므로 유지보수 및 확장하기 쉬움; classes는 실제 세계의 개체를 모델링하므로 설계가 이해하기 쉬움; polymorphism은 동일한 호출이 서로 다른 객체에서도 작동하게 함.

가상 코드(pseudocode)의 클래스, Paper 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()로 사용됨. 자급 class는 SUPER를 통해 부모의 constructor를 재사용함:

CLASS ElectricCar INHERITS Car
    PRIVATE BatteryCapacity : REAL
    PUBLIC PROCEDURE NEW(NewReg : STRING, NewYear : INTEGER, NewCapacity : REAL)
        SUPER.NEW(NewReg, NewYear)
        BatteryCapacity ← NewCapacity
    ENDPROCEDURE
ENDCLASS

Python의 동일 클래스, Paper 4의 기준: 속성은 이중 언더스코어(++)로 private로 설정, constructor는 __init__, 자급 class는 대괄호로 부모를 명시하고 super().__init__(…)을 호출함:

class Car:
    def __init__(self, reg, year):
        self.__registration = reg
        self.__year = year
        self.__mileage = 0
    def get_mileage(self):
        return self.__mileage
    def add_mileage(self, extra):
        self.__mileage = self.__mileage + extra

class ElectricCar(Car):
    def __init__(self, reg, year, capacity):
        super().__init__(reg, year)
        self.__capacity = capacity

cars = []
cars.append(Car("AB12 CDE", 2020))
cars.append(ElectricCar("EV21 XYZ", 2023, 75.0))
cars[1].add_mileage(150)
print(cars[1].get_mileage())

Java에서는 동일한 개념이 private/public 필드, 클래스 이름의 생성자, extends 및 super(…)으로 표현됩니다. VB.NET에서는 Private/Public, Sub New, Inherits 및 MyBase.New입니다. 폴리모피직 메서드는 부모에 작성되어 자식에서 동일한 이름으로 오버라이드되며, 부모 타입 변수를 통한 호출은 자식의 버전을 실행합니다.

데이터 구조를 객체로. Paper 4는 속성이 데이터와 다른 노드에 대한 하나 또는 두 개의 참조인 Node 클래스를 사용하여 스택, 연결 목록 또는 이진 트리를 구축합니다. Tree(또는 LinkedList) 클래스는 루트(또는 시작점)와 메서드를 보유합니다.

CLASS Node
    PUBLIC Data : INTEGER
    PUBLIC Left : Node          // NULL when there is no child
    PUBLIC RightRef : Node
    PUBLIC PROCEDURE NEW(NewData : INTEGER)
        Data ← NewData
        Left ← NULL
        RightRef ← 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.RightRef = NULL THEN
                        Current.RightRef ← NewNode
                        Placed ← TRUE
                    ELSE
                        Current ← Current.RightRef
                    ENDIF
                ENDIF
            ENDWHILE
        ENDIF
    ENDPROCEDURE
ENDCLASS

find 메서드는 동일한 경로를 따라 이동하며, Current.Data = Target일 때 TRUE을 반환하고, NULL에 도달하면 FALSE을 반환함; 중위 순회 output 메서드는 재귀적임: 왼쪽 서브트리, 현재 노드, 오른쪽 서브트리를 순서대로 출력함. 연결리스트에서는 노드가 하나의 참조, 즉 Next를 가지며, 리스트 class는 Start를 보유함; 리스트로 구현된 스택에서는 push와 pop 모두 Start에서 작동함.

작업 예제. 게임에는 캐릭터가 있습니다. 각 캐릭터는 이름, 시작값이 100인 체력, X와 Y로 주어진 위치를 가집니다. 생성자와 메서드 Move(DX, DY)를 가진 클래스 Character를 작성하십시오. 그런 다음, 시작값이 50인 Mana를 추가하고, 10의 마나를 받아 충분한 경우 TRUE를 반환하는 메서드 CastSpell()를 포함하는 하위 클래스 Wizard를 작성하십시오.

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'는 레코드를 순회하는 방법을 말하기보다 원하는 결과를 명시합니다.

사실, 규칙 및 목표는 선언적 패러다임에서 시험에서 다루는 핵심 개념입니다. 다음 사실(참인 문장)과 규칙(조건이 성립할 때 성립하는 결론)이 주어졌을 때:

01 type(leopard, wild).
02 type(lion, wild).
03 type(tabby, domestic).
04 size(leopard, large).
05 size(lion, large).
06 size(tabby, small).
07 dangerous(X) IF type(X, wild) AND size(X, large).

"목표 type(X, wild)의 결과를 작성하시오": X = leopard, X = lion. 엔진은 목표와 각각의 사실을 순차적으로 대조합니다; 모든 일치하는 결과가 해답이 되며, 대문자는 변수로서 일치하는 값을 채워 넣습니다. "여우가 야생임을 보여주는 사실을 작성하시오": type(cheetah, wild). "라인 07이 하는 일을 설명하시오": 이는 결론이 dangerous(X)인 규칙을 정의합니다. 이는 야생이면서 크기인 모든 X에 대해 참이므로, dangerous(A)는 A = leopard, A = lion을 반환합니다. "규칙을 작성하시오: 특정 기능 F는 body style B에 사용 가능할 수 있으며, 조건으로 F가 기능이고 B이 body style이며, F이 B에서 사용 불가하지 않을 때이다": may_be_available(F, B) IF feature(F) AND body_style(B) AND NOT unavailable(F, B). 문제의 사실에 사용된 정확한 추론(name)과 인자 순서를 그대로 복사하십시오. 새로운 사실은 마침표로 끝내야 하며, 규칙의 조건들은 AND로 연결됩니다.

패러다임 비교

현대 언어들은 종종 패러다임을 혼합합니다. Python은 절차적, OOP, 함수형을 모두 지원합니다. 적절한 선택은 문제에 따라 달라집니다.

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.

전체 파일을 읽기:

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"

파일 내재 수정

대부분의 언어는 텍스트 파일을 내재(in-place)로 편집할 수 없습니다. 대신: 원본 파일을 READ 모드로 열고 임시 파일을 WRITE 모드로 엽니다. 각 줄에 대해 변경해야 하면 새 버전을, 그렇지 않으면 원본을 작성합니다. 두 파일을 모두 닫은 후, 원본을 임시 파일로 교체합니다. 같은 패턴은 줄 삭제(건너뜀) 및 삽입에도 적용됩니다.

레코드와 랜덤 접근 파일

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.

세 가지 파일 조직. 직렬 파일에서는 레코드가 추가된 순서대로 저장됩니다. 순차 파일에서는 키(key) 순서대로 저장되며, 둘 다 시작점에서 읽습니다. 랜덤 파일(직접 접근 파일)은 해싱(hash) 함수를 통해 키에서 계산된 주소(address) 에 각 레코드를 저장하므로, 다른 레코드 없이 특정 레코드를 찾을 수 있습니다. 레코드는 사용자 정의 타입으로 선언됩니다:

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로 매핑하고, 이미 점유된 슬롯을 건너뛰고 다음 빈 위치로 이동합니다. 마크는 해시 값, GET 또는 PUT 이전의 SEEK, 타겟과의 비교, 충돌 처리, 파일 닫기 등에 적용됩니다.

Worked example. ActiveFile.dat holds AccountRecord records. Write pseudocode that copies every record whose Active field is FALSE to the end of 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"

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.

주의사항

파일을 닫지 않는 것(데이터 분실 가능); APPEND을 의도했을 때 WRITE로 픈(모두 상치 overwritten); EOF를 넘어 읽음; 하드코딩된 경로 — /Users/Admin/data.txt와 같은 경로는 다른 기계에서 작동하지 않으므로, DataFile = "./data/scores.txt"와 같은 상대 상수를 사용하십시오.

예외는 실행 중 발생하는 오류나 예상치 못한 상태—0으로 나누기, 파일 불 finds, 네트워크 오류, 배열 인덱스 범위를 초과하는 경우 등—to 예외 처리는 프로그램이 이를 감지하여 gracefully(부드럽게) 대응하게 하고, 충돌을 방지합니다.

실제 프로그램은 초기에 방지할 수 없는 오류(파일 이동, 네트워크 다운, 잘못된 입력 등)를 마주하므로 중요합니다. 예외 처리가 없으면 모든 연산마다 자체 IF 확인이 필요하며, 정상 흐름과 오류 처리를 분리하여 주요 로직이 깔끔하게 읽히도록 합니다. 예를 들어, 파일을 존재 여부 확인 후 실제 열기 사이에 다른 사용자가 삭제할 수 있는데, 이는 방지할 수 없으므로 발생 시 실패를 처리해야 합니다.

"예를 들어 exception이 무엇인지 설명하시오" (2점). 프로그램 실행 중(런타임) 발생하여 정상적인 흐름을 방해하는 예기치 않은 이벤트 또는 오류; 예를 들어 0으로 나누기, 존재하지 않는 파일 열기, 비숫자 입력을 정수로 변환, 배열 인덱스 범위를 벗어남, 또는 메모리 부족 등. "exception의 가능한 원인 두 가지를 식별하시오" 는 해당 목록에서 답변하며, "장비나 네트워크 사용 불가" 및 "무효한 데이터 타입 입력"도 포함됩니다.

"exception 처리를 포함하는 이유를 명시하시오" (3점). 프로그램이 크래시(예기치 않게 종료됨)하는 것을 방지하기 위해; 시스템 오류 대신 사용자에게 의미 있는 메시지를 출력하기 위해; 예를 들어 입력을 다시 요청하거나, 종료 전에 파일을 안전하게 닫아 프로그램을 복구하고 계속 진행할 수 있게 하기 위해; 그리고some errors program is written when cannot be predicted because some errors. "exception due to program termination can be avoided describe how": try block inside statements that might raise the exception; 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.

패턴

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

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).

예외 발생

오류를 감지하는 서브루틴이 예외를 발생시켜 호출자가 처리할 수 있습니다:

FUNCTION Divide(a : INTEGER, b : INTEGER) RETURNS INTEGER
    IF b = 0 THEN
        RAISE DivideByZero
    ENDIF
    RETURN a DIV b
ENDFUNCTION

예외 처리 위치

대응이 단순한 경우(메시지, 재시도 등)는 오류 근처에서 처리하고, 외부 코드만 대응 방법을 아는 경우에는 호출 스택의 상위 단계에서 처리합니다. (상위 GUI 루프가 오류를 로그에 기록하고 친절한 대화상자를 표시하는 식입니다.) 예외를 조용히 흡수하지 마십시오 — 적어도 로그에 기록해야 디버깅이 가능합니다.

일반적인 예외: FileNotFound, IOError, DivisionByZero, IndexOutOfRange, InvalidArgument, NullReference, OutOfMemory. 실패하는 각 연산을 적절한 EXCEPT 핸들러가 있는 TRY로 감싸면 프로그램이 충돌하기보다 점진적으로 성능이 저하됩니다.

작업 예제 (Paper 4). 파일 이름을 매개변수로 받아 한 줄에 하나의 정수를 읽어서 리스트로 반환하는 함수를 작성하십시오. 파일이 존재하지 않거나 줄에 정수가 아닌 값이 포함되어 있어도 프로그램이 crash되지 않아야 합니다.

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

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.

해설 예제. 회원 정보 텍스트 파일에서 한 회원의 전화번호를 변경해야 합니다. 왜 단순히 해당 줄을 덮어쓸 수 없는지, 그리고 그 패턴은 무엇인지 설명하십시오. 텍스트 파일의 줄 길이는 다르며, 파일 내에는 차이를 수용할 여백이 없습니다: 더 긴 교체 문장은 다음 레코드와 겹치며, 더 짧은 문장은 구문 일부를 남겨둡니다. 따라서 패턴은 원본 파일을 READ 모드로 열고 임시 파일을 WRITE 모드로 연 뒤, 줄을 순차적으로 읽어 변경되는 줄에는 새로운 버전을, 나머지는 원본 줄을 그대로 써서 양쪽 파일을 닫고, 마지막으로 임시 파일을 사용하여 원본 파일을 교체하는 것입니다. 삭제(줄 건너뛰기)나 삽입(추가 줄 쓰기)도 동일한 패턴으로 처리할 수 있습니다. 모든 줄을 쓸어야 하며, 변경된 줄뿐만 아니라 다른 줄들도 반드시 씁니다. 새 레코드만 쓰고 나머지 파일 내용을 잃어버리는 것이 고전적인 실수입니다.

정의 문제는 고정된 문구로 채점합니다. 이 내용들을 정확히 외우고, 답은 하나만 제시하십시오.

• 패러다임: 각 패러다임의 한 줄 설명을 알고 코드 샘플에서 패러다임을 식별할 수 있어야 함; 저수준 질문은 5가지 주소 지정 방식과 accumulator가 받는 값을 묻음.
• OOP 정의는 매 세션마다 등장함: class, object, attribute, method, encapsulation, inheritance, polymorphism, constructor. PRIVATE 속성, PUBLIC NEW 및 getter가 있는 클래스를 더미문으로 작성; INHERITS와 SUPER.NEW가 있는 하위 클래스 작성.
• 서술적: 변수가 있는 목표는 모든 일치하는 사실을 반환; AND로 연결된 조건이 참이면 결론이 되는 규칙; 문제의 predicate 이름을 정확히 복사.
• 파일: 세 가지 모드와 기존 파일에 미치는 영향; READFILE을 WHILE NOT EOF 루프에서 사용; 무작위 파일은 해시, SEEK, GETRECORD 및 PUTRECORD를 사용하며 충돌 시 스텝오버 적용.
• 예외: 예외 정의와 예시, 예외 처리가 필요한 세 가지 이유, TRY와 명명된 EXCEPT를 사용하여 프로그램이 계속 작동하도록 함.

흔한 실수

• 서술적 프로그램을 "정답을 제공하는 단계의 나열"로 묘사; 어떻게 하는지가 아니라 참인 것과 원하는 것이 무엇인지 명시.
• 객체와 클래스, 또는 인스턴스와 속성을 혼동; '객체의 발생'이라는 질문에는 instance가 정답.
• 속성을 PUBLIC으로 선언하거나 getter를 거치지 않고 클래스 외부에서 직접 접근하여 캡슐화 점수 상실.
• 하위 클래스 컨스트럭터에서 SUPER.NEW를 호출하지 않고 부모의 속성을 직접 설정.
• 다형성을 '여러 객체'로 설명; 같은 메서드 이름이 서로 다른 클래스에서 다르게 동작해야 함.
• RECORD를 추가하기 위해 FOR WRITE로 파일을 열면 기존 내용이 삭제됨; APPEND를 사용.
• 시작점에서 무작위 파일을 읽기; 먼저 해시된 주소로 SEEK.
• 실할 수 없는 코드 주변에 예외 처리기를 두거나 메시지 없이 모든 것을 잡거나, 예외 처리를 'IF로 입력 확인'이라고 묘사.