정보처리기사 실기 - 2023년 3회 - 문제해설

정보처리기사 실기 - 2023년 3회 복원문제 해설

 

📋 목차

1. Java 상속 및 메서드 오버라이딩

2. OAuth 인증 프로토콜

3. Linux 파일 권한

4. C언어 완전수

5. C언어 구조체 포인터

6. SQL UNION 연산

7. 서버 접근 통제 유형

8. C언어 재귀함수 팩토리얼

9. ATM 전송 방식

10. C언어 포인터

11. Java 재귀함수

12. NAT 기술

13. Java static 메서드

14. Python 입출력

15. UML 다이어그램

16. 동등 분할 기법

17. 클라우드 서비스 유형

18. RIP 프로토콜

19. 관계 대수 기호

20. 참조 무결성

 

---

 

문제 1: Java 상속 및 메서드 오버라이딩

 

문제 코드

 

public class main{

    public static void main(String[] args) {

        A b = new B();

        b.paint();

        b.draw();

    }

}

 

class A {

    public void paint() {

        System.out.print("A");

        draw();

    }

    public void draw() {

        System.out.print("B");

        draw();

    }

}

 

class B extends A {

    public void paint() {

        super.draw();

        System.out.print("C");

        this.draw();

    }

    public void draw() {

        System.out.print("D");

    }

}

 

정답

BDCDD

 

상세 해설

 

실행 흐름 분석

 

1. A b = new B();  // B 타입 객체를 A 타입 변수에 저장 (다형성)

2. b.paint();      // B 클래스의 paint() 메서드 호출 (오버라이딩)

3. b.draw();       // B 클래스의 draw() 메서드 호출 (오버라이딩)

 

단계별 실행 과정

 

1단계: b.paint() 호출

 

// B 클래스의 paint() 메서드 실행

public void paint() {

    super.draw();      // ← A 클래스의 draw() 호출

    System.out.print("C");

    this.draw();       // ← B 클래스의 draw() 호출

}

 

A 클래스의 draw() 실행:

public void draw() {

    System.out.print("B");  // 출력: "B"

    draw();                  // ← 재귀 호출? 아니면 B의 draw() 호출?

}

 

중요 개념: 동적 바인딩 (Dynamic Binding)

• super.draw()는 A 클래스의 draw()를 호출

• 하지만 A 클래스의 draw() 내부에서 draw()를 호출하면, 실제 객체 타입(B)의 draw()가 호출됨

• 따라서 A의 draw() → B의 draw() 호출

 

실제 실행:

super.draw() 실행

  → A.draw() 시작

  → System.out.print("B")  // 출력: "B"

  → draw() 호출 (동적 바인딩으로 B.draw() 호출)

    → B.draw() 실행

    → System.out.print("D")  // 출력: "D"

  → A.draw() 종료

→ System.out.print("C")  // 출력: "C"

→ this.draw() 실행

  → B.draw() 실행

  → System.out.print("D")  // 출력: "D"

 

출력: BDCD

 

2단계: b.draw() 호출

 

// B 클래스의 draw() 메서드 실행

public void draw() {

    System.out.print("D");  // 출력: "D"

}

 

출력: D

 

최종 출력

BDCDD

 

핵심 개념

 

1. 다형성 (Polymorphism)

• A b = new B(): B 타입 객체를 A 타입 변수에 저장
• 변수 타입은 A이지만 실제 객체는 B

2. A b = new B(): B 타입 객체를 A 타입 변수에 저장

3. 변수 타입은 A이지만 실제 객체는 B

 

1. 메서드 오버라이딩 (Method Overriding)

• B 클래스가 A 클래스의 paint()와 draw()를 재정의
• 호출 시 실제 객체 타입(B)의 메서드가 실행됨

2. B 클래스가 A 클래스의 paint()와 draw()를 재정의

3. 호출 시 실제 객체 타입(B)의 메서드가 실행됨

 

1. 동적 바인딩 (Dynamic Binding)

• 실행 시점에 실제 객체 타입에 따라 메서드 결정
• super.draw() 내부의 draw() 호출도 B의 draw()로 바인딩됨

2. 실행 시점에 실제 객체 타입에 따라 메서드 결정

3. super.draw() 내부의 draw() 호출도 B의 draw()로 바인딩됨

 

1. super와 this

• super.draw(): 부모 클래스(A)의 메서드 호출
• this.draw(): 현재 클래스(B)의 메서드 호출

2. super.draw(): 부모 클래스(A)의 메서드 호출

3. this.draw(): 현재 클래스(B)의 메서드 호출

 

---

 

문제 2: OAuth 인증 프로토콜

 

문제 설명

사용자가 사용자 이름 및 암호와 같은 자격 증명을 공유하지 않고도 타사 애플리케이션이 데이터 또는 리소스에 액세스할 수 있도록 권한을 부여할 수 있는 개방형 표준 프로토콜

 

정답

ㅇ (OAuth)

 

상세 해설

 

OAuth란?

 

**OAuth (Open Authorization)**는 사용자가 자격 증명을 공유하지 않고도 타사 애플리케이션에 리소스 접근 권한을 부여할 수 있는 개방형 표준 프로토콜입니다.

 

OAuth의 주요 특징

 

1. 자격 증명 보호

• 사용자의 ID/비밀번호를 타사 앱에 공유하지 않음
• 액세스 토큰을 통해 인증

2. 사용자의 ID/비밀번호를 타사 앱에 공유하지 않음

3. 액세스 토큰을 통해 인증

 

1. 액세스 토큰 기반

• 사용자가 권한 부여 → 앱이 액세스 토큰 받음
• 토큰으로 리소스 접근

2. 사용자가 권한 부여 → 앱이 액세스 토큰 받음

3. 토큰으로 리소스 접근

 

1. 사용자 제어

• 사용자가 언제든지 권한 취소 가능
• 특정 리소스만 선택적으로 권한 부여 가능

2. 사용자가 언제든지 권한 취소 가능

3. 특정 리소스만 선택적으로 권한 부여 가능

 

OAuth 동작 흐름

 

┌─────────┐         ┌──────────┐         ┌─────────┐

│ 사용자  │         │ 타사 앱  │         │ 리소스  │

│         │         │          │         │ 서버    │

└────┬────┘         └────┬─────┘         └────┬────┘

     │                   │                     │

     │ 1. 리소스 접근 요청                      │

     │──────────────────>│                     │

     │                   │                     │

     │ 2. 인증 페이지로 리다이렉트              │

     │<──────────────────│                     │

     │                   │                     │

     │ 3. 로그인 및 권한 부여                   │

     │─────────────────────────────────────────>│

     │                   │                     │

     │ 4. 인증 코드 발급                        │

     │<─────────────────────────────────────────│

     │                   │                     │

     │ 5. 인증 코드 전달                        │

     │──────────────────>│                     │

     │                   │                     │

     │ 6. 액세스 토큰 요청                      │

     │                   │─────────────────────>│

     │                   │                     │

     │ 7. 액세스 토큰 발급                      │

     │                   │<─────────────────────│

     │                   │                     │

     │ 8. 리소스 접근 (토큰 사용)               │

     │                   │─────────────────────>│

     │                   │                     │

     │ 9. 리소스 반환                           │

     │                   │<─────────────────────│

 

OAuth 사용 사례

 

서비스용도

Facebook	소셜 로그인, 타사 앱에 프로필 정보 공유
Twitter	타사 앱에서 트윗 작성 권한 부여
Google	Google Drive, Gmail 등 리소스 접근
GitHub	저장소 접근 권한 부여
LinkedIn	프로필 정보 접근 권한 부여

 

보기 항목 설명

 

기호용어설명

ㄱ	NFT	Non-Fungible Token (대체 불가능한 토큰)
ㄴ	JWT	JSON Web Token (인증 토큰 형식)
ㄷ	SAML	Security Assertion Markup Language (SSO 프로토콜)
ㄹ	accessToken	OAuth에서 사용하는 접근 토큰
ㅁ	SSO	Single Sign-On (단일 로그인)
ㅂ	OIDC	OpenID Connect (OAuth 2.0 기반 인증)
ㅅ	Authentication	인증 (신원 확인)
ㅇ	OAuth	개방형 인증 프로토콜 ✅
ㅈ	Cookie	웹 브라우저 쿠키
ㅊ	Refresh Token	액세스 토큰 갱신용 토큰

 

---

 

문제 3: Linux 파일 권한

 

문제

리눅스에서 사용자에게 읽기/쓰기/실행 권한을 부여하고, 그룹에게는 읽기/실행을 부여하고, 그 이외에는 실행 권한을 test.txt 파일에 부여하는 명령어

 

정답

(1) chmod
(2) 751

 

상세 해설

 

Linux 파일 권한 구조

 

Linux 파일 권한은 3가지 주체와 3가지 권한으로 구성됩니다.

 

주체 (Owner):

• u (user): 파일 소유자

• g (group): 그룹

• o (others): 기타 사용자

 

권한 (Permission):

• r (read): 읽기 권한 (4)

• w (write): 쓰기 권한 (2)

• x (execute): 실행 권한 (1)

 

8진법 권한 표기

 

8진법2진법권한설명

0	000	---	권한 없음
1	001	--x	실행만
2	010	-w-	쓰기만
3	011	-wx	쓰기+실행
4	100	r--	읽기만
5	101	r-x	읽기+실행
6	110	rw-	읽기+쓰기
7	111	rwx	읽기+쓰기+실행

 

문제 해결 과정

 

요구사항:

• 사용자(u): 읽기(r) + 쓰기(w) + 실행(x) = 7 (4+2+1)

• 그룹(g): 읽기(r) + 실행(x) = 5 (4+1)

• 기타(o): 실행(x) = 1

 

8진법 표기:

7 5 1

│ │ │

│ │ └─ others: 실행 (1)

│ └─── group: 읽기+실행 (5)

└───── user: 읽기+쓰기+실행 (7)

 

명령어:

chmod 751 test.txt

 

chmod 명령어 사용법

 

8진법 사용:

chmod 751 test.txt

 

문자 모드 사용:

chmod u=rwx,g=rx,o=x test.txt

# 또는

chmod u+rwx,g+rx,o+x test.txt

 

권한 확인

 

ls -l test.txt

# 출력: -rwxr-x--x 1 user group 0 Jan 30 12:00 test.txt

#       └─┬─┘└─┬─┘└─┬─┘

#         │    │    └─ others: --x (1)

#         │    └───── group: r-x (5)

#         └────────── user: rwx (7)

 

---

 

문제 4: C언어 완전수

 

문제 코드

 

#include <stdio.h>

 

int test(int n) {

    int i, sum = 0;

 

    for (i = 1; i <= n / 2; i++){

        if (n % i == 0)

        sum += i;

    }

 

    if (n == sum) 

        return 1;

    

    return 0;

}

 

 

int main(){

    int i, sum=0;

 

    for (i = 2; i <= 100; i++){ 

        if (test(i))

        sum += i;

    }

    

    printf("%d ", sum); 

    return 0;

}

 

정답

34

 

상세 해설

 

완전수 (Perfect Number)란?

 

완전수는 자신을 제외한 모든 약수의 합이 자신과 같은 수입니다.

 

예시:

• 6 = 1 + 2 + 3 (약수: 1, 2, 3, 6)

• 28 = 1 + 2 + 4 + 7 + 14 (약수: 1, 2, 4, 7, 14, 28)

 

코드 분석

 

test(int n) 함수:

int test(int n) {

    int i, sum = 0;

    

    // 1부터 n/2까지 반복 (약수는 n/2 이하에만 존재)

    for (i = 1; i <= n / 2; i++){

        if (n % i == 0)  // i가 n의 약수인지 확인

            sum += i;     // 약수 합계에 추가

    }

    

    if (n == sum)  // 약수의 합이 자신과 같으면 완전수

        return 1;

    

    return 0;

}

 

main() 함수:

int main(){

    int i, sum=0;

    

    // 2부터 100까지 완전수 찾기

    for (i = 2; i <= 100; i++){ 

        if (test(i))      // 완전수이면

            sum += i;     // 합계에 추가

    }

    

    printf("%d ", sum); 

    return 0;

}

 

완전수 찾기 과정

 

2부터 100까지 확인:

 

숫자약수 (자신 제외)약수 합완전수?

2	1	1	❌
3	1	1	❌
4	1, 2	3	❌
5	1	1	❌
6	1, 2, 3	6	✅
7	1	1	❌
...	...	...	...
28	1, 2, 4, 7, 14	28	✅
...	...	...	...
100	1, 2, 4, 5, 10, 20, 25, 50	117	❌

 

완전수:

• 6 (약수 합: 1+2+3 = 6)

• 28 (약수 합: 1+2+4+7+14 = 28)

 

합계:

6 + 28 = 34

 

실행 흐름도

 

main() 시작

  ↓

i = 2부터 100까지 반복

  ↓

  test(i) 호출

    ↓

    약수 찾기 (1 ~ i/2)

    ↓

    약수 합계 계산

    ↓

    n == sum? → 완전수 확인

    ↓

  완전수이면 sum += i

  ↓

합계 출력: 34

 

---

 

문제 5: C언어 구조체 포인터

 

문제 코드

 

#include <stdio.h>

#include <stdlib.h>

 

typedef struct Data{

    char c;

    int *numPtr; 

} Data;

 

int main(){

    int num = 10;

    Data d1;    

    Data *d2 = malloc(sizeof(struct Data));

    

    d1.numPtr = &num;  

    d2 ( ) numPtr = &num; 

 

    printf("%d\n", *d1.numPtr); 

    printf("%d\n", *d2 ( ) numPtr);

 

    free(d2); 

    return 0;

}

 

정답

→

 

상세 해설

 

구조체 포인터 접근

 

구조체 변수 접근:

Data d1;           // 구조체 변수

d1.numPtr = &num;  // . (점) 연산자 사용

 

구조체 포인터 접근:

Data *d2;          // 구조체 포인터

d2->numPtr = &num; // -> (화살표) 연산자 사용

 

연산자 비교

 

연산자사용 대상예시

.	구조체 변수	d1.numPtr
->	구조체 포인터	d2->numPtr

 

동등 관계:

d2->numPtr  // 포인터 사용

// 동일한 의미:

(*d2).numPtr  // 역참조 후 점 연산자

 

코드 분석

 

Data d1;                    // 구조체 변수

Data *d2 = malloc(...);     // 구조체 포인터

 

d1.numPtr = &num;          // . 연산자 (변수)

d2->numPtr = &num;          // -> 연산자 (포인터)

 

printf("%d\n", *d1.numPtr);    // d1.numPtr 역참조

printf("%d\n", *d2->numPtr);   // d2->numPtr 역참조

 

실행 결과:

10

10

 

메모리 구조

 

┌─────────┐

│  num    │ ← 값: 10

│  (10)   │

└────┬────┘

     │

     │ &num

     │

┌────▼─────────┐      ┌──────────────┐

│ d1           │      │ d2 (포인터)   │

│ ┌──────────┐ │      │ ┌──────────┐  │

│ │ numPtr ──┼─┼──────┼─┤ numPtr ──┼──┼──┐

│ └──────────┘ │      │ └──────────┘  │  │

└──────────────┘      └──────────────┘  │

                                              │

                                              ▼

                                         ┌─────────┐

                                         │  num    │

                                         │  (10)   │

                                         └─────────┘

 

---

 

문제 6: SQL UNION 연산

 

문제

 

테이블:

 

T1

A

3

1

4

 

T2

A

2

4

3

 

쿼리:

SELECT A FROM T1

UNION

SELECT A FROM T2

ORDER BY A DESC;

 

정답

4

3

2

1

 

상세 해설

 

UNION 연산

 

UNION은 두 개 이상의 SELECT 문의 결과를 합치되, 중복을 제거합니다.

 

UNION vs UNION ALL:

• UNION: 중복 제거

• UNION ALL: 중복 포함

 

실행 과정

 

1단계: T1 선택

A

─

3

1

4

 

2단계: T2 선택

A

─

2

4

3

 

3단계: UNION (중복 제거)

T1 ∪ T2 (중복 제거)

A

─

3  (T1)

1  (T1)

4  (T1, T2 중복 → 하나만)

2  (T2)

3  (T1, T2 중복 → 하나만)

 

중복 제거 후:

A

─

1

2

3

4

 

4단계: ORDER BY A DESC (내림차순 정렬)

A

─

4

3

2

1

 

시각적 표현

 

T1:        T2:        UNION:      ORDER BY DESC:

┌───┐      ┌───┐      ┌───┐       ┌───┐

│ 3 │      │ 2 │      │ 1 │       │ 4 │

│ 1 │  ∪   │ 4 │  =   │ 2 │  →   │ 3 │

│ 4 │      │ 3 │      │ 3 │       │ 2 │

└───┘      └───┘      │ 4 │       │ 1 │

                      └───┘       └───┘

                   (중복 제거)   (내림차순)

 

---

 

문제 7: 서버 접근 통제 유형

 

문제 설명

 

1. 규칙 기반(Rule-Based) 접근통제 정책으로, 객체에 포함된 정보의 허용 등급과 접근 정보에 대하여 주체가 갖는 접근 허가 권한에 근거하여 객체에 대한 접근을 제한하는 방법

 

1. 중앙 관리자가 사용자와 시스템의 상호관계를 통제하며 조직 내 맡은 역할(Role)에 기초하여 자원에 대한 접근을 제한하는 방법

 

1. 신분 기반(Identity-Based) 접근통제 정책으로, 주체나 그룹의 신분에 근거하여 객체에 대한 접근을 제한하는 방법

 

정답

(1) MAC
(2) RBAC
(3) DAC

 

상세 해설

 

접근 통제 모델 비교

 

모델약자설명특징

MAC	Mandatory Access Control	강제 접근 통제	규칙 기반, 중앙 관리
DAC	Discretionary Access Control	임의 접근 통제	신분 기반, 사용자 제어
RBAC	Role-Based Access Control	역할 기반 접근 통제	역할 기반, 중앙 관리

 

1. MAC (Mandatory Access Control)

 

특징:

• 규칙 기반 접근 통제

• 객체의 보안 등급과 주체의 보안 허가 등급 비교

• 중앙 관리자가 모든 접근 권한 통제

• 사용자가 권한 변경 불가

 

예시:

┌─────────────┐

│ 보안 등급   │

│ ┌─────────┐ │

│ │ 비밀    │ │ ← 높은 등급

│ │ 기밀    │ │

│ │ 일반    │ │ ← 낮은 등급

│ └─────────┘ │

└─────────────┘

 

주체의 허가 등급 ≥ 객체의 보안 등급 → 접근 허용

 

사용 사례:

• 군사 시스템

• 정부 기관

• 고보안 환경

 

2. RBAC (Role-Based Access Control)

 

특징:

• 역할(Role) 기반 접근 통제

• 사용자에게 역할 부여 → 역할에 권한 할당

• 중앙 관리자가 역할과 권한 관리

• 사용자 관리가 용이

 

구조:

사용자 → 역할 → 권한 → 리소스

 

예시:

사용자: 김철수

  ↓

역할: 관리자

  ↓

권한: 읽기, 쓰기, 삭제

  ↓

리소스: 모든 파일

 

예시:

역할: 관리자

  └─ 권한: 모든 파일 읽기/쓰기/삭제

 

역할: 일반 사용자

  └─ 권한: 자신의 파일만 읽기/쓰기

 

역할: 게스트

  └─ 권한: 읽기만

 

3. DAC (Discretionary Access Control)

 

특징:

• 신분 기반 접근 통제

• 객체 소유자가 접근 권한 결정

• 사용자가 자신의 리소스에 대한 권한 부여/취소 가능

• 임의적 접근 통제

 

예시:

파일 소유자: 김철수

  ├─ 읽기 권한: 이영희

  ├─ 쓰기 권한: 박민수

  └─ 실행 권한: 최지영

 

김철수가 직접 권한 관리

 

사용 사례:

• 일반 파일 시스템 (Windows, Linux)

• 개인 문서 관리

 

비교표

 

항목MACDACRBAC

제어 방식	규칙 기반	신분 기반	역할 기반
권한 관리	중앙 관리자	객체 소유자	중앙 관리자
유연성	낮음	높음	중간
보안성	매우 높음	낮음	높음
사용 사례	군사/정부	일반 파일 시스템	기업 시스템

 

---

 

문제 8: C언어 재귀함수 팩토리얼

 

문제 코드

 

#include <stdio.h>

 

int f(int n) {

    if(n<=1) return 1;

    else return n*f(n-1);

}

 

int main() {

    printf("%d", f(7));

}

 

정답

5040

 

상세 해설

 

팩토리얼 (Factorial)

 

팩토리얼은 1부터 n까지의 모든 양의 정수를 곱한 값입니다.

 

수식:

n! = n × (n-1) × (n-2) × ... × 2 × 1

 

예시:

• 0! = 1

• 1! = 1

• 2! = 2 × 1 = 2

• 3! = 3 × 2 × 1 = 6

• 4! = 4 × 3 × 2 × 1 = 24

 

재귀 함수 분석

 

int f(int n) {

    if(n<=1) return 1;        // 기저 조건 (Base Case)

    else return n*f(n-1);     // 재귀 호출

}

 

재귀 구조:

f(n) = n × f(n-1)

f(n-1) = (n-1) × f(n-2)

...

f(1) = 1

 

f(7) 실행 과정

 

f(7)

  = 7 × f(6)

      = 7 × (6 × f(5))

          = 7 × (6 × (5 × f(4)))

              = 7 × (6 × (5 × (4 × f(3))))

                  = 7 × (6 × (5 × (4 × (3 × f(2)))))

                      = 7 × (6 × (5 × (4 × (3 × (2 × f(1))))))

                          = 7 × (6 × (5 × (4 × (3 × (2 × 1)))))

                              = 7 × (6 × (5 × (4 × (3 × 2))))

                                  = 7 × (6 × (5 × (4 × 6)))

                                      = 7 × (6 × (5 × 24))

                                          = 7 × (6 × 120)

                                              = 7 × 720

                                                  = 5040

 

실행 스택

 

호출 스택:

┌─────────┐

│ f(1)    │ ← return 1

│ f(2)    │ ← return 2 × 1 = 2

│ f(3)    │ ← return 3 × 2 = 6

│ f(4)    │ ← return 4 × 6 = 24

│ f(5)    │ ← return 5 × 24 = 120

│ f(6)    │ ← return 6 × 120 = 720

│ f(7)    │ ← return 7 × 720 = 5040

└─────────┘

 

계산 과정 표

 

단계계산결과

f(1)	1	1
f(2)	2 × f(1) = 2 × 1	2
f(3)	3 × f(2) = 3 × 2	6
f(4)	4 × f(3) = 4 × 6	24
f(5)	5 × f(4) = 5 × 24	120
f(6)	6 × f(5) = 6 × 120	720
f(7)	7 × f(6) = 7 × 720	5040

 

---

 

문제 9: ATM 전송 방식

 

문제 설명

• 자료를 일정한 크기로 정하여 순서대로 전송하는 자료의 전송 방식

• 셀이라 부르는 고정 길이 패킷을 이용하여 처리가 단순하고 고속망에 적합

• 가상 채널 (Virtual Channel) 기반의 연결 지향 서비스

• 셀이라 부르는 고정 길이(53바이트) 패킷을 사용하며 통계적 다중화 방식을 이용

 

정답

ATM

 

상세 해설

 

ATM이란?

 

**ATM (Asynchronous Transfer Mode)**은 비동기 전송 모드로, 고정 길이의 셀(Cell)을 사용하는 패킷 전송 방식입니다.

 

ATM의 주요 특징

 

1. 고정 길이 셀

• 셀 크기: 53바이트
• 헤더: 5바이트
• 페이로드: 48바이트

2. 셀 크기: 53바이트

3. 헤더: 5바이트

4. 페이로드: 48바이트

 

1. 연결 지향 서비스

• 가상 채널(Virtual Channel) 사용
• 데이터 전송 전 연결 설정 필요

2. 가상 채널(Virtual Channel) 사용

3. 데이터 전송 전 연결 설정 필요

 

1. 고속 전송

• 처리가 단순하여 고속망에 적합
• 하드웨어 기반 스위칭

2. 처리가 단순하여 고속망에 적합

3. 하드웨어 기반 스위칭

 

1. 통계적 다중화

• 대역폭을 효율적으로 사용
• 필요에 따라 동적 할당

2. 대역폭을 효율적으로 사용

3. 필요에 따라 동적 할당

 

ATM 셀 구조

 

┌─────────────────────────────────────┐

│ ATM 셀 (53바이트)                    │

├─────────────────────────────────────┤

│ 헤더 (5바이트)                       │

│ ┌─────────────────────────────────┐ │

│ │ GFC │ VPI │ VCI │ PT │ CLP │ HEC │ │

│ └─────────────────────────────────┘ │

├─────────────────────────────────────┤

│ 페이로드 (48바이트)                  │

│ ┌─────────────────────────────────┐ │

│ │         데이터 (48바이트)        │ │

│ └─────────────────────────────────┘ │

└─────────────────────────────────────┘

 

헤더 필드:

• GFC: 일반 흐름 제어

• VPI: 가상 경로 식별자

• VCI: 가상 채널 식별자

• PT: 페이로드 타입

• CLP: 셀 손실 우선순위

• HEC: 헤더 오류 제어

 

ATM vs 다른 전송 방식

 

방식패킷 크기특징

ATM	고정 (53바이트)	고속, 연결 지향
Ethernet	가변 (64~1518바이트)	LAN에 적합
Frame Relay	가변	WAN에 적합

 

ATM 사용 사례

 

• 고속 네트워크 백본

• 멀티미디어 전송

• 실시간 통신

• B-ISDN (Broadband ISDN)

 

---

 

문제 10: C언어 포인터

 

문제 코드

 

#include <stdio.h>

 

int main() {

    char* p = "KOREA";

    printf("%s\n", p);

    printf("%s\n", p+1);

    printf("%c\n", *p);

    printf("%c\n", *(p+3));

    printf("%c\n", *p+4);

}

 

정답

KOREA

OREA

K

E

O

 

상세 해설

 

문자열 포인터

 

char* p = "KOREA";

 

메모리 구조:

p → [K][O][R][E][A][\0]

     ↑

   p가 가리키는 위치

 

각 출력문 분석

 

1. printf("%s\n", p);

p → "KOREA"

출력: KOREA

 

2. printf("%s\n", p+1);

p+1 → "OREA"  (p에서 1바이트 이동)

출력: OREA

 

3. printf("%c\n", *p);

*p → 'K'  (p가 가리키는 문자)

출력: K

 

4. printf("%c\n", *(p+3));

p+3 → 'E' 위치

*(p+3) → 'E'

출력: E

 

5. printf("%c\n", *p+4);

*p → 'K' (ASCII: 75)

*p+4 → 75 + 4 = 79

79 → 'O' (ASCII)

출력: O

 

메모리 구조도

 

메모리:

┌─────┬─────┬─────┬─────┬─────┬─────┐

│  K  │  O  │  R  │  E  │  A  │ \0  │

└─────┴─────┴─────┴─────┴─────┴─────┘

  ↑     ↑     ↑     ↑     ↑

  p    p+1   p+2   p+3   p+4

 

ASCII 값:

K = 75

O = 79 (75 + 4)

 

단계별 출력

 

코드의미출력

p	문자열 시작 주소	KOREA
p+1	두 번째 문자부터	OREA
*p	첫 번째 문자	K
*(p+3)	네 번째 문자	E
*p+4	첫 번째 문자 값 + 4	O (75+4=79)

 

---

 

문제 11: Java 재귀함수

 

문제 코드

 

class Parent {

    int compute(int num) {

        if(num <= 1)

            return num;

        return compute(num-1) + compute(num-2);

    }

}

 

class Child extends Parent {

    int compute(int num) {

        if(num <= 1)

            return num;

        return compute(num-1) + compute(num-3);

    }

}

 

public class main {

    public static void main(String args[]) {

        Parent obj = new Child();

        System.out.print(obj.compute(7));

    }

}

 

정답

2

 

상세 해설

 

다형성과 메서드 오버라이딩

 

Parent obj = new Child();

obj.compute(7);  // Child 클래스의 compute() 호출

 

중요: obj는 Parent 타입이지만 실제 객체는 Child이므로 Child의 compute()가 실행됩니다.

 

재귀 함수 분석

 

Child 클래스의 compute():

int compute(int num) {

    if(num <= 1)

        return num;

    return compute(num-1) + compute(num-3);  // ← num-2가 아닌 num-3!

}

 

재귀 구조:

compute(n) = compute(n-1) + compute(n-3)

 

compute(7) 실행 과정

 

compute(7)

  = compute(6) + compute(4)

    = (compute(5) + compute(3)) + (compute(3) + compute(1))

      = ((compute(4) + compute(2)) + (compute(2) + compute(0))) + 

        ((compute(2) + compute(0)) + 1)

        = ...

 

전체 계산 트리:

 

compute(7)

├─ compute(6)

│  ├─ compute(5)

│  │  ├─ compute(4)

│  │  │  ├─ compute(3) = compute(2) + compute(0) = 1 + 0 = 1

│  │  │  └─ compute(1) = 1

│  │  │     = 1 + 1 = 2

│  │  └─ compute(2)

│  │     ├─ compute(1) = 1

│  │     └─ compute(-1) = -1

│  │        = 1 + (-1) = 0

│  │     = 2 + 0 = 2

│  └─ compute(3)

│     ├─ compute(2) = 0

│     └─ compute(0) = 0

│        = 0 + 0 = 0

│     = 2 + 0 = 2

└─ compute(4)

   ├─ compute(3) = 0

   └─ compute(1) = 1

      = 0 + 1 = 1

   = 2 + 1 = 3

 

계산표:

 

ncompute(n)계산

≤1	n	기저 조건
0	0	-
1	1	-
2	compute(1) + compute(-1) = 1 + (-1) = 0	-
3	compute(2) + compute(0) = 0 + 0 = 0	-
4	compute(3) + compute(1) = 0 + 1 = 1	-
5	compute(4) + compute(2) = 1 + 0 = 1	-
6	compute(5) + compute(3) = 1 + 0 = 1	-
7	compute(6) + compute(4) = 1 + 1 = 2	✅

 

최종 답: 2

 

---

 

문제 12: NAT 기술

 

문제

IP 패킷에서 외부의 공인 IP주소와 포트 주소에 해당하는 내부 IP주소를 재기록하여 라우터를 통해 네트워크 트래픽을 주고받는 기술

 

정답

NAT (Network Address Translation)

 

상세 해설

 

NAT란?

 

**NAT (Network Address Translation)**은 네트워크 주소 변환 기술로, 사설 IP 주소를 공인 IP 주소로 변환하는 기술입니다.

 

NAT의 목적

 

1. IPv4 주소 부족 문제 해결

• 공인 IP 주소 절약
• 여러 사설 IP가 하나의 공인 IP 공유

2. 공인 IP 주소 절약

3. 여러 사설 IP가 하나의 공인 IP 공유

 

1. 보안 강화

• 내부 네트워크 구조 숨김
• 외부에서 직접 접근 불가

2. 내부 네트워크 구조 숨김

3. 외부에서 직접 접근 불가

 

1. 네트워크 관리 용이

• 내부 IP 변경 시 외부 영향 없음

2. 내부 IP 변경 시 외부 영향 없음

 

NAT 동작 원리

 

┌─────────────┐         ┌──────────┐         ┌─────────────┐

│ 내부 네트워크│         │ NAT      │         │ 인터넷      │

│             │         │ 라우터   │         │             │

│ 192.168.1.10│────────>│          │────────>│ 203.0.113.1 │

│             │         │ 변환     │         │             │

│ 192.168.1.20│────────>│          │────────>│ (공인 IP)   │

│             │         │          │         │             │

└─────────────┘         └──────────┘         └─────────────┘

  (사설 IP)              (공인 IP)

 

NAT 변환 과정

 

1. 내부 → 외부 (Outbound)

내부: 192.168.1.10:5000

  ↓ NAT 변환

외부: 203.0.113.1:6000

 

2. 외부 → 내부 (Inbound)

외부: 203.0.113.1:6000

  ↓ NAT 변환

내부: 192.168.1.10:5000

 

NAT 테이블

 

내부 IP:포트공인 IP:포트프로토콜

192.168.1.10:5000	203.0.113.1:6000	TCP
192.168.1.20:3000	203.0.113.1:6001	TCP
192.168.1.30:8080	203.0.113.1:6002	TCP

 

NAT 유형

 

1. Static NAT

• 1:1 매핑
• 고정된 변환

2. 1:1 매핑

3. 고정된 변환

 

1. Dynamic NAT

• 여러 사설 IP → 여러 공인 IP
• 동적 할당

2. 여러 사설 IP → 여러 공인 IP

3. 동적 할당

 

1. PAT (Port Address Translation)

• 여러 사설 IP → 하나의 공인 IP
• 포트 번호로 구분

2. 여러 사설 IP → 하나의 공인 IP

3. 포트 번호로 구분

 

---

 

문제 13: Java static 메서드

 

문제 코드

 

class Person {

    private String name;

    public Person(String val) {

        name = val;

    }

    public static String get() {

        return name;  // ← 에러 발생 라인

    }

    public void print() {

        System.out.println(name);

    }

}

public class main {

    public static void main(String[] args) {

        Person obj = new Person("Kim");

        obj.print();

    }

}

 

정답

7

 

상세 해설

 

에러 원인

 

문제 코드:

public static String get() {

    return name;  // ← 에러!

}

 

에러 메시지:

non-static variable name cannot be referenced from a static context

 

static 메서드의 특징

 

1. 인스턴스 없이 호출 가능

Person.get();  // 객체 생성 없이 호출 가능

 

1. 인스턴스 변수 접근 불가

• static 메서드는 객체에 속하지 않음
• 인스턴스 변수(name)는 객체에 속함
• 따라서 접근 불가

2. static 메서드는 객체에 속하지 않음

3. 인스턴스 변수(name)는 객체에 속함

4. 따라서 접근 불가

 

메모리 구조

 

┌─────────────────────┐

│ 클래스 영역          │

│ ┌─────────────────┐ │

│ │ static 메서드    │ │ ← get() 메서드

│ │ (객체 없이 존재) │ │

│ └─────────────────┘ │

└─────────────────────┘

         │

         │ 접근 불가!

         │

┌────────▼────────────┐

│ 인스턴스 영역        │

│ ┌─────────────────┐ │

│ │ name (인스턴스)  │ │ ← 객체마다 다른 값

│ └─────────────────┘ │

└─────────────────────┘

 

해결 방법

 

방법 1: static 제거

public String get() {  // static 제거

    return name;

}

 

방법 2: 인스턴스 변수를 static으로 변경 (비권장)

private static String name;  // 모든 객체가 공유

 

방법 3: 매개변수로 전달

public static String get(Person p) {

    return p.name;

}

 

static vs 인스턴스

 

항목static인스턴스

소속	클래스	객체
메모리	클래스 영역	힙 영역
호출	클래스.메서드()	객체.메서드()
인스턴스 변수 접근	❌ 불가	✅ 가능
static 변수 접근	✅ 가능	✅ 가능

 

---

 

문제 14: Python 입출력

 

문제 코드

 

print("파이썬 입출력에 대한 문제입니다.")

 

num1, num2 = input()._____()

num1 = int(num1)

num2 = int(num2)

print(num1,num2)

 

num3 = num1 + num2

print(num1 + " + "  + num2 + " = " + num3)

 

입력값: 2 3
출력화면:

파이썬 입출력에 대한 문제입니다.

2 3

2 + 3 = 5

 

정답

split

 

상세 해설

 

input() 함수

 

**input()**은 사용자로부터 한 줄의 문자열을 입력받습니다.

 

input()  # "2 3" 입력 시 → "2 3" (문자열)

 

split() 메서드

 

**split()**은 문자열을 공백(또는 지정된 구분자)으로 나누어 리스트로 반환합니다.

 

"2 3".split()  # → ['2', '3']

 

코드 분석

 

num1, num2 = input().split()

# 입력: "2 3"

# "2 3".split() → ['2', '3']

# num1 = '2', num2 = '3'

 

num1 = int(num1)  # '2' → 2

num2 = int(num2)  # '3' → 3

 

print(num1, num2)  # 2 3

 

num3 = num1 + num2  # 2 + 3 = 5

print(num1 + " + " + num2 + " = " + num3)

# 에러! num1, num2는 int이므로 문자열과 결합 불가

 

수정된 코드:

print(str(num1) + " + " + str(num2) + " = " + str(num3))

# 또는

print(f"{num1} + {num2} = {num3}")

 

실행 흐름

 

입력: "2 3"

  ↓

input() → "2 3"

  ↓

split() → ['2', '3']

  ↓

num1 = '2', num2 = '3'

  ↓

int() 변환

  ↓

num1 = 2, num2 = 3

  ↓

출력: 2 3

  ↓

num3 = 5

  ↓

출력: 2 + 3 = 5

 

split() 메서드 옵션

 

"a b c".split()        # ['a', 'b', 'c'] (공백 기준)

"a,b,c".split(',')     # ['a', 'b', 'c'] (쉼표 기준)

"a b c".split(' ', 1)  # ['a', 'b c'] (최대 1번만 분할)

 

---

 

문제 15: UML 다이어그램

 

문제

판매와 관련된 다이어그램 이미지 (패키지 다이어그램)

 

 

 

정답

패키지

 

상세 해설

 

UML 패키지 다이어그램

 

패키지 다이어그램은 시스템의 구조를 패키지 단위로 표현하는 다이어그램입니다.

 

패키지 다이어그램의 특징

 

1. 모듈화

• 관련 요소들을 그룹화
• 패키지로 시스템 구조 표현

2. 관련 요소들을 그룹화

3. 패키지로 시스템 구조 표현

 

1. 의존성 표현

• 패키지 간 의존 관계 표시
• 점선 화살표로 표현

2. 패키지 간 의존 관계 표시

3. 점선 화살표로 표현

 

1. 네임스페이스

• 패키지 내 요소들의 네임스페이스 제공

2. 패키지 내 요소들의 네임스페이스 제공

 

패키지 다이어그램 예시

 

┌─────────────┐

│   판매      │

│  패키지     │

│             │

│ ┌─────────┐ │

│ │ 주문    │ │

│ │ 관리    │ │

│ └─────────┘ │

│             │

│ ┌─────────┐ │

│ │ 결제    │ │

│ │ 처리    │ │

│ └─────────┘ │

└─────────────┘

      │

      │ 의존

      ▼

┌─────────────┐

│   재고      │

│  패키지     │

└─────────────┘

 

UML 다이어그램 종류

 

다이어그램용도

패키지	시스템 구조, 모듈화
클래스	클래스 구조, 관계
시퀀스	시간 순서 상호작용
활동	업무 흐름
상태	객체 상태 변화

 

---

 

문제 16: 동등 분할 기법

 

문제 설명

• 시스템이나 시스템 구성요소의 입력값과 출력값이 특정 그룹으로 분류되며, 분류된 그룹내의 값들이 시스템에 의해 동일하게 취급된다는 특성을 이용하여 시험하는 기법

• 유사한 입력값들이 시스템을 거치면서 유사한 답변이 나온다는 것을 가정하여 테스트

• 하나의 값은 그 분할 내 모든 값을 대표하는 것으로 간주하는 기법

• 모든 입력값을 시험할 필요가 없게 하여 시험을 효율적으로 수행하도록 지원

• 일반적으로 경계값 분석기법(boundary value analysis)과 함께 테스트 케이스 도출하는데 사용

 

정답

ㄱ (Equivalence Partitioning)

 

상세 해설

 

동등 분할 (Equivalence Partitioning)

 

동등 분할은 입력값을 유사한 동작을 하는 그룹으로 나누어 각 그룹의 대표값만 테스트하는 기법입니다.

 

동등 분할의 원리

 

가정:

• 같은 그룹의 값들은 동일하게 처리됨

• 하나의 값으로 그룹 전체를 대표할 수 있음

 

예시: 나이 입력 검증

입력값: 나이 (0 ~ 150)

 

동등 분할:

┌─────────────┬─────────────┬─────────────┐

│ 유효하지 않음│   유효함     │ 유효하지 않음│

│   (음수)     │  (0~150)    │  (150 초과) │

└─────────────┴─────────────┴─────────────┘

 

테스트 케이스:

- -1 (유효하지 않음 그룹 대표)

- 75 (유효함 그룹 대표)

- 200 (유효하지 않음 그룹 대표)

 

동등 분할 vs 경계값 분석

 

동등 분할:

• 그룹의 대표값 테스트

• 효율적인 테스트 케이스 생성

 

경계값 분석:

• 경계값과 그 주변 값 테스트

• 경계에서 오류 발생 가능성 높음

 

함께 사용:

동등 분할로 그룹 식별

  ↓

경계값 분석으로 경계 테스트

  ↓

종합적인 테스트 케이스

 

보기 항목 설명

 

기호용어설명

ㄱ	Equivalence Partitioning	동등 분할 ✅
ㄴ	Statement Coverage	문장 커버리지
ㄷ	Boundary Value Analysis	경계값 분석
ㄹ	Branch Coverage	분기 커버리지
ㅁ	Error Guessing	오류 추정
ㅂ	Condition Coverage	조건 커버리지
ㅅ	Cause Effect Graph	원인 결과 그래프

 

---

 

문제 17: 클라우드 서비스 유형

 

문제

클라우드 서비스 유형 이미지 (IaaS, PaaS, SaaS)

정답

(1) IaaS
(2) PaaS
(3) SaaS

 

상세 해설

 

클라우드 서비스 모델

 

클라우드 서비스는 3가지 모델로 구분됩니다.

 

1. IaaS (Infrastructure as a Service)

 

제공 내용:

• 가상화된 하드웨어 인프라

• 서버, 스토리지, 네트워크

 

사용자 관리:

• OS, 미들웨어, 애플리케이션, 데이터

 

예시:

• AWS EC2

• Google Compute Engine

• Azure Virtual Machines

 

비유:

IaaS = 빈 땅

  → 사용자가 집을 지어야 함

 

2. PaaS (Platform as a Service)

 

제공 내용:

• 개발 플랫폼

• OS, 미들웨어, 런타임 환경

 

사용자 관리:

• 애플리케이션, 데이터

 

예시:

• Heroku

• Google App Engine

• AWS Elastic Beanstalk

 

비유:

PaaS = 아파트 (인프라 + 플랫폼)

  → 사용자가 인테리어만 하면 됨

 

3. SaaS (Software as a Service)

 

제공 내용:

• 완성된 소프트웨어 애플리케이션

 

사용자 관리:

• 데이터만 관리

 

예시:

• Gmail

• Office 365

• Salesforce

 

비유:

SaaS = 호텔 (모든 것 제공)

  → 사용자는 이용만 하면 됨

 

비교표

 

항목IaaSPaaSSaaS

제공	인프라	플랫폼	소프트웨어
관리	OS 이상	애플리케이션 이상	데이터만
제어	높음	중간	낮음
유연성	높음	중간	낮음
예시	EC2	Heroku	Gmail

 

시각적 표현

 

사용자 관리 영역:

┌─────────────────────────────────┐

│ 애플리케이션, 데이터             │ ← SaaS

├─────────────────────────────────┤

│ OS, 미들웨어, 런타임            │ ← PaaS

├─────────────────────────────────┤

│ 서버, 스토리지, 네트워크        │ ← IaaS

└─────────────────────────────────┘

클라우드 제공자 관리

 

---

 

문제 18: RIP 프로토콜

 

문제 설명

• 최소 Hop count를 파악하여 라우팅하는 프로토콜

• 거리와 방향으로 길을 찾아가는 Distance Vector 다이나믹 프로토콜

• 최단거리 즉, Hop count가 적은 경로를 택하여 라우팅하는 프로토콜로 Routing Table에 인접 라우터 정보를 저장하여 경로를 결정

• 최대 Hop count는 15로 거리가 짧기 때문에 IGP로 많이 이용하는 프로토콜

 

정답

RIP

 

상세 해설

 

RIP란?

 

**RIP (Routing Information Protocol)**은 거리 벡터 기반의 동적 라우팅 프로토콜입니다.

 

RIP의 주요 특징

 

1. Distance Vector 프로토콜

• 거리(홉 수)와 방향으로 경로 결정
• 인접 라우터와 정보 교환

2. 거리(홉 수)와 방향으로 경로 결정

3. 인접 라우터와 정보 교환

 

1. Hop Count 기반

• 최소 홉 수를 최단 경로로 간주
• 최대 홉 수: 15
• 16 이상은 무한대(도달 불가)로 간주

2. 최소 홉 수를 최단 경로로 간주

3. 최대 홉 수: 15

4. 16 이상은 무한대(도달 불가)로 간주

 

1. IGP (Interior Gateway Protocol)

• 자율 시스템(AS) 내부에서 사용
• 작은 네트워크에 적합

2. 자율 시스템(AS) 내부에서 사용

3. 작은 네트워크에 적합

 

RIP 동작 원리

 

라우터 A          라우터 B          라우터 C

    │                │                │

    │  라우팅 정보   │                │

    │──────────────>│                │

    │                │  라우팅 정보   │

    │                │──────────────>│

    │                │                │

    │  최단 경로 계산│                │

    │<──────────────│                │

 

라우팅 테이블 예시

 

목적지다음 홉홉 수메트릭

192.168.1.0	직접 연결	0	-
192.168.2.0	라우터 B	1	1
192.168.3.0	라우터 B	2	2

 

RIP vs 다른 프로토콜

 

프로토콜타입특징

RIP	Distance Vector	홉 수 기반, 최대 15홉
OSPF	Link State	링크 상태 기반, 대규모 네트워크
BGP	Path Vector	경로 벡터, AS 간 라우팅

 

RIP의 한계

 

1. 최대 홉 수 제한 (15)

• 큰 네트워크에 부적합

2. 큰 네트워크에 부적합

 

1. 수렴 속도 느림

• 라우팅 루프 발생 가능

2. 라우팅 루프 발생 가능

 

1. 대역폭 사용

• 주기적으로 전체 라우팅 테이블 전송

2. 주기적으로 전체 라우팅 테이블 전송

 

---

 

문제 19: 관계 대수 기호

 

문제

1. join: ( 1 )

2. project: ( 2 )

3. select: ( 3 )

4. division: ( 4 )

 

보기:
ㄱ. σ ㄴ. π ㄷ.⋈ ㄹ.÷

 

정답

(1) ㄷ (⋈)
(2) ㄴ (π)
(3) ㄱ (σ)
(4) ㄹ (÷)

 

상세 해설

 

관계 대수 기호

 

관계 대수는 관계형 데이터베이스에서 데이터를 조작하는 수학적 연산입니다.

 

기호와 의미

 

연산기호설명

Select	σ	조건에 맞는 행 선택
Project	π	지정된 열만 선택
Join	⋈	두 관계를 결합
Division	÷	나눗셈 연산

 

1. Select (σ)

 

의미: 조건에 맞는 튜플(행) 선택

 

문법:

σ조건(관계)

 

예시:

-- SQL

SELECT * FROM 학생 WHERE 나이 > 20;

 

-- 관계 대수

σ나이>20(학생)

 

2. Project (π)

 

의미: 지정된 속성(열)만 선택

 

문법:

π속성1,속성2(관계)

 

예시:

-- SQL

SELECT 이름, 나이 FROM 학생;

 

-- 관계 대수

π이름,나이(학생)

 

3. Join (⋈)

 

의미: 두 관계를 결합

 

문법:

관계1 ⋈ 관계2

 

예시:

-- SQL

SELECT * FROM 학생 JOIN 수강 ON 학생.학번 = 수강.학번;

 

-- 관계 대수

학생 ⋈ 수강

 

4. Division (÷)

 

의미: 나눗셈 연산 (모든 조건을 만족하는 튜플 선택)

 

문법:

관계1 ÷ 관계2

 

예시:

학생(학번, 이름)

수강(학번, 과목)

 

학생 ÷ 수강

→ 모든 과목을 수강한 학생

 

관계 대수 연산자 정리

 

연산자기호SQL 대응

Select	σ	WHERE
Project	π	SELECT
Join	⋈	JOIN
Union	∪	UNION
Intersection	∩	INTERSECT
Difference	-	EXCEPT
Division	÷	(복잡한 쿼리)

 

---

 

문제 20: 참조 무결성

 

문제 설명

• 관계 데이터베이스 관계 모델에서 2개의 관련 있던 관계 변수(테이블) 간의 일관성(데이터 무결성)을 말한다

• 종종 기본 키 또는 키가 아닌 후보 키와 외래 키의 조합으로 강제 적용된다

• 외래 키가 선언된 관계 변수의 외래 키를 구성하는 속성(열)의 값은 그 관계 변수의 부모가 되는 관계 변수의 기본 키 값 또는 기본 키가 아닌 후보 키 값으로 존재해야 한다

 

정답

참조

 

상세 해설

 

참조 무결성 (Referential Integrity)

 

참조 무결성은 관계형 데이터베이스에서 두 테이블 간의 참조 관계가 일관되게 유지되는 것을 보장하는 제약 조건입니다.

 

참조 무결성의 원리

 

규칙:

• 외래 키(Foreign Key) 값은 반드시 참조하는 테이블의 기본 키(Primary Key) 또는 후보 키(Candidate Key) 값으로 존재해야 함

• 존재하지 않는 값을 참조할 수 없음

 

예시

 

부모 테이블 (학과):

학과코드학과명

CS	컴퓨터과학
EE	전기공학
ME	기계공학

 

자식 테이블 (학생):

학번이름학과코드

001	김철수	CS
002	이영희	CS
003	박민수	PH

 

PH는 학과 테이블에 존재하지 않음

 

참조 무결성 제약 조건

 

1. 삽입 제약

학생 테이블에 새 레코드 삽입 시

  → 학과코드는 학과 테이블에 존재해야 함

 

2. 삭제 제약

학과 테이블에서 레코드 삭제 시

  → 해당 학과를 참조하는 학생이 있으면 삭제 불가

  → 또는 CASCADE 삭제 (학생도 함께 삭제)

 

3. 수정 제약

학과 테이블의 기본 키 수정 시

  → 참조하는 학생의 외래 키도 함께 수정

  → 또는 수정 불가

 

참조 무결성 시각화

 

┌──────────────┐         ┌──────────────┐

│   학과       │         │   학생       │

│ (부모)       │         │ (자식)       │

├──────────────┤         ├──────────────┤

│ 학과코드(PK) │◄────────│ 학과코드(FK) │

│ 학과명       │         │ 학번(PK)     │

└──────────────┘         │ 이름         │

                        └──────────────┘

                        

FK는 반드시 PK를 참조해야 함

 

CASCADE 옵션

 

ON DELETE CASCADE:

학과 삭제 → 해당 학과 학생도 자동 삭제

 

ON UPDATE CASCADE:

학과코드 변경 → 학생의 학과코드도 자동 변경

 

데이터 무결성 종류

 

무결성설명

참조 무결성	외래 키와 기본 키 간의 일관성
개체 무결성	기본 키의 고유성과 NULL 불가
도메인 무결성	속성 값의 유효성
사용자 정의 무결성	사용자가 정의한 규칙

 

---

 

전체 문제 정리

 

문제주제정답

1	Java 상속/오버라이딩	BDCDD
2	OAuth	ㅇ
3	Linux 파일 권한	chmod 751
4	C언어 완전수	34
5	C언어 구조체 포인터	→
6	SQL UNION	4,3,2,1
7	접근 통제	MAC, RBAC, DAC
8	C언어 팩토리얼	5040
9	ATM	ATM
10	C언어 포인터	KOREA, OREA, K, E, O
11	Java 재귀함수	2
12	NAT	NAT
13	Java static	7
14	Python split	split
15	UML 패키지	패키지
16	동등 분할	ㄱ
17	클라우드	IaaS, PaaS, SaaS
18	RIP	RIP
19	관계 대수	⋈, π, σ, ÷
20	참조 무결성	참조

 

---

 

학습 포인트

 

프로그래밍 언어

• ✅ Java: 상속, 다형성, 오버라이딩, static

• ✅ C언어: 포인터, 구조체, 재귀함수, 완전수

• ✅ Python: 입출력, split()

 

데이터베이스

• ✅ SQL: UNION 연산

• ✅ 관계 대수: 기호와 의미

• ✅ 무결성: 참조 무결성

 

네트워크/보안

• ✅ OAuth 인증 프로토콜

• ✅ NAT 기술

• ✅ RIP 프로토콜

• ✅ ATM 전송 방식

• ✅ 접근 통제: MAC, DAC, RBAC

 

소프트웨어 공학

• ✅ 테스트 기법: 동등 분할

• ✅ UML: 패키지 다이어그램

• ✅ 클라우드: IaaS, PaaS, SaaS

 

시스템

• ✅ Linux: 파일 권한 (chmod)

 

이 문서를 통해 정보처리기사 실기 시험을 준비할 수 있습니다!