#include <stdio.h>
int Add(int size, int a[]) {
int i, sum = 0;
for (i=0; i<size; i++) sum += a[i];
a[0] = 20;
return sum;
}
void main() {
int i, b[3];
b[0] = 2; b[1] = 4; b[2] = 8;
printf("the sum = %d\n", Add(3, b));
for (i=0; i<3; i++) printf("%d", b[i]);
printf("\n");
}
C에서 배열 b를 넘기면 배열의 시작 주소가 전달되므로 이는 참조에 의한 전달(Call by reference)의 효과를 낸다.
함수 안의 a[0] = 20 이 호출한 쪽 b[0] 을 바로 바꾸므로, 출력되는 b 는 20, 4, 8 이 된다. 배열 이름은 첫 원소의 주소로 변환되어 주소 값이 복사되기 때문이다.
- Call by value: 배열 원소 전체가 복사되어 원본이 보호되는 방식이 아니므로 맞지 않다.
- Call by value result: 복귀 시 값을 되돌려 쓰는 복사-복원 방식은 C에 없다.
- Call by name: 인자 식을 사용할 때마다 다시 평가하는 방식으로 Algol 60 등의 개념이며 C에는 없다.
옳지 않은 것은 Java가 C++보다 실행 속도도 더 빠르다는 설명이다.
Java는 바이트코드를 가상 기계(JVM)에서 실행하고 가비지 컬렉션 등의 부담이 있어, 일반적으로 네이티브 코드로 컴파일되는 C++보다 실행 속도가 빠르다고 할 수 없다. 객체지향에 충실한 것과 실행 속도는 별개의 문제다.
- 프로그램의 중심 단위가 C++은 함수, Java는 클래스라는 설명은 옳다.
- C++가 C with classes 로 출발해 C에 클래스 개념을 추가한 언어라는 설명은 옳다.
- C++는 다중 상속을 지원하고 Java는 단일 상속만 지원하며 인터페이스로 다중 상속 효과를 낸다는 설명은 옳다.
#include <stdio.h>
void main() {
float a = 3/2;
float b = 3.0/2;
int c = (int)b;
printf("%7.3f%7.3f%3d\n", a, b, c);
}
출력은 1.000 1.500 1 이다.
3/2 는 정수끼리의 나눗셈이라 먼저 정수 1로 계산된 뒤 float 로 변환되어 a = 1.0 이 된다.
3.0/2 는 실수 나눗셈이라 b = 1.5 이고, (int)b 는 소수부를 버려 c = 1 이다.
- a 를 1.500 으로 본 결과: 3/2 가 정수 나눗셈임을 놓친 것이다.
- b 를 1.000 으로 본 결과: 3.0 이 실수이므로 실수 나눗셈이 수행된다.
- c 를 2 로 본 결과: int 형변환은 반올림이 아니라 소수부 절삭이다.
옳지 않은 것은 재귀 하강 파싱을 LR 파싱의 한 종류로 든 설명이다.
재귀 하강 파싱은 비단말마다 프로시저를 두어 시작 기호부터 내려가는 하향식(top-down) 방법이다. LR 계열에는 SLR, CLR(정규 LR), LALR 이 있다.
- 좌파스를 만드는 것이 하향식, 우파스를 만드는 것이 상향식이라는 구분은 옳다.
- 추상 구문 트리는 불필요한 중간 노드를 생략하므로 파스트리보다 기억 공간이 효율적이다.
- 결정적 하향식 파싱(LL)을 위해 FIRST, FOLLOW 집합을 이용한다는 설명은 옳다.
interface A {
int a = 1;
public int aa();
}
interface B {
int a = 2;
public int bb();
}
interface C extends A, B {
int a = 3;
public int cc();
}
class D implements C {
public int aa() { return (5); }
public int bb() { return (6); }
public int cc() { return (7); }
}
class iTest {
public static void main(String args[]) {
A da = new D();
C dc = new D();
D dd = new D();
System.out.println(da.a + dc.a + dd.a + dd.cc());
}
}출력값은 14 이다.
인터페이스의 필드는 static 상수이고, 참조 변수의 선언 타입(정적 타입)으로 어떤 a 인지 결정된다.
da 는 A 타입이므로 A.a = 1, dc 는 C 타입이므로 C.a = 3, dd 는 D 타입이며 D 는 C 만 구현하므로 C 의 a 를 상속해 3 이다.
dd.cc() 는 7 이므로 1 + 3 + 3 + 7 = 14 이다.
- 10 은 세 참조의 a 를 모두 A 의 a = 1 로 본 값(1 + 1 + 1 + 7)이다.
- 13 은 dd.a 를 2 로 본 경우로, D 는 B 를 직접 구현하지 않으므로 맞지 않다.
- 16 은 da.a 를 객체의 실제 타입 기준 3 으로 본 경우로, 필드는 동적 바인딩되지 않는다.
class Test {
Test() { System.out.println("C()"); }
Test(int n) { System.out.println("C(I)"); } // ㉠
void m() { System.out.println("()V"); } // ㉡
void m(long n) { System.out.println("(L)V"); } // ㉢
int m(long n) { System.out.println("(L)I"); // ㉣
return (int)n; } // ㉣
}컴파일 오류의 원인은 반환형만 다르고 매개변수가 같은 void m(long n) 과 int m(long n) 의 충돌이므로, ㉠·㉡을 제거하는 조치는 옳지 않다.
Java의 오버로딩은 이름과 매개변수 목록(시그너처)으로만 구분하며 반환형은 구분 기준이 아니다. 따라서 ㉢이나 ㉣ 중 하나가 제거되어야 컴파일된다.
- ㉡, ㉢을 제거하면 m(long) 은 ㉣ 하나만 남아 충돌이 사라진다.
- ㉡, ㉣을 제거하면 m(long) 은 ㉢ 하나만 남아 충돌이 사라진다.
- ㉢, ㉣을 모두 제거해도 충돌하던 두 메소드가 없어져 정상 컴파일된다.
옳지 않은 것은 예외 처리 기능이 내장되면 프로그램이 더 길고 복잡해진다는 설명이다.
언어가 예외 처리를 지원하면 오류 검사 코드를 곳곳에 직접 넣을 필요가 없어, 프로그래머가 직접 처리할 때보다 프로그램이 간결하고 읽기 쉬워진다.
- 예외 전파로 하나의 처리기가 여러 프로그램 단위의 예외를 다뤄 개발 비용을 줄인다는 설명은 옳다.
- 사용자 정의 처리기로 시스템의 조악한 기본 처리 대신 세밀한 처리와 메시지를 쓸 수 있다는 설명은 옳다.
- 컴파일러가 지정된 예외를 검사하는 코드를 목적 코드에 삽입한다는 설명은 옳다.
공용 자원에 비배타적으로 접근해 실행 순서에 따라 결과가 달라지는 상황은 경쟁 조건(race condition)이다.
두 프로세스가 R 을 읽고 1 을 더해 쓰는 과정이 끼어들면 한쪽의 갱신이 사라져 1만 증가할 수 있다.
- 경쟁 동기화: 경쟁 조건을 막기 위해 상호 배제를 보장하는 동기화 기법이지 상황 자체가 아니다.
- 교착 상태: 서로가 가진 자원을 기다리며 영원히 진행하지 못하는 상태다.
- 협동 동기화: 한 프로세스가 다른 프로세스의 작업 완료를 기다리는 순서 조정 기법이다.
옳은 것은 포인터 변수 p 의 r-값은 p 가 가리키는 위치(저장된 주소), l-값은 p 자신이 저장된 위치라는 설명이다.
l-값은 변수의 기억 장소 위치, r-값은 그 위치에 저장된 값이다. 포인터는 저장된 값이 주소이므로 r-값이 곧 가리키는 위치가 된다.
- ref 로 l-값과 r-값을 구별하는 언어는 Algol 68 이며, Bliss 는 변수 이름을 l-값으로 보고 점(.) 연산자로 r-값을 얻는다.
- 연산자가 들어있는 수식은 계산 결과인 r-값은 있지만 저장 위치인 l-값은 일반적으로 없으므로 거꾸로 서술되었다.
- 변수 이름이 배정문 좌우 어디서나 같은 값을 뜻하는 언어는 Bliss 이고 그 값은 r-값이 아니라 l-값(위치)이다. Algol 68 은 ref 형과 문맥에 따른 역참조로 l-값과 r-값을 구별한다.
iconst_1
iconst_2
iconst_3
imul
iconst_4
iadd
imul
실행 후 스택 꼭대기에는 10 이 남는다.
iconst_1, iconst_2, iconst_3 으로 스택은 [1, 2, 3] 이 된다.
imul 이 위의 두 값을 곱해 [1, 6], iconst_4 로 [1, 6, 4] 가 된다.
iadd 로 [1, 10], 마지막 imul 로 1 × 10 = 10 이다.
- -2: 명령이 곱셈과 덧셈뿐이고 상수가 모두 양수이므로 음수는 나올 수 없다.
- 4: iconst_4 로 넣은 4 는 iadd 에서 6 과 더해져 소비되므로 꼭대기에 남지 않는다.
- 28: 스택의 후입선출 순서를 따르면 6 + 4 를 먼저 구한 뒤 남은 1 과 곱하므로 28 이 나올 수 없다.
옳은 것은 a 배열이 필요로 하는 기억장소 용량이 번역 시간에 확정된다는 설명이다.
원소 수 10 과 원소형 int 가 선언에 고정되어 있으므로 컴파일러는 크기를 미리 계산할 수 있는 정적 크기 배열이다.
- 배열 이름 a 는 수정할 수 없는 l-값이므로 a = 10; 같은 배정은 허용되지 않는다.
- 선언된 크기는 고정되어 실행 중에 배열 크기가 변하지 않는다.
- 지역 배열이라면 실제 주소는 함수가 호출될 때 스택 프레임 위치에 따라 실행 시간에 정해지므로 컴파일러가 결정한다고 할 수 없다.
int sum(int a[], int n) {
int i, s = 0;
for (i=0; i<n; i++)
s += a[i];
return s;
}int sum(int *a, int n) {
int i = 0, s = 0;
while (i<n)
s += a[i++];
return s;
}int sum(int a[], int n) {
int i, s = 0;
for (i=0; i<n; i++)
s += *a++;
return s;
}int sum(int *a, int n) {
int i = 0, s = 0;
while (i<n)
s += a[i]++;
return s;
}의미가 다른 것은 s += a[i]++; 를 쓰는 함수다.
a[i]++ 는 첨자 i 가 아니라 원소 a[i] 의 값을 증가시킨다. i 가 증가하지 않아 a[0] 만 반복해 더하며 루프가 끝나지 않고 배열 내용도 바뀐다.
- for 문과 a[i] 로 더하는 함수는 a[0] 부터 a[n-1] 까지의 합을 구한다.
- while 문에서 a[i++] 로 더하는 함수는 첨자를 증가시키며 같은 합을 구한다.
- *a++ 로 더하는 함수는 포인터를 다음 원소로 옮기며 같은 합을 구한다.
옳지 않은 것은 생성자를 객체를 생성하는 메소드로 설명한 것이다.
객체의 기억 공간 할당은 new 등 생성 연산이 담당하고, 생성자는 생성된 객체의 멤버를 초기화하기 위해 자동 호출되는 메소드다.
- 소멸자는 객체가 소멸될 때 자동으로 실행되어 자원을 정리하는 메소드라는 설명은 옳다.
- 클래스는 유사한 객체들의 공통 속성과 행위를 묶어 정의한 틀이라는 설명은 옳다.
- 추상 메소드는 구현부 없이 시그너처만 선언된 메소드라는 설명은 옳다.
옳은 것은 효율적인 실행을 목표로 하는 언어는 바인딩을 주로 번역 시간에 수행한다는 설명이다.
바인딩을 일찍 할수록 실행 중 결정할 일이 줄어 효율이 높아지고, 늦게 할수록 융통성이 높아진다.
- 자료형이 표현할 수 있는 값의 범위는 하드웨어에 맞춰 언어 구현 시간에 결정되는 경우가 일반적이다.
- 언어 구현 시간 바인딩을 최소화하면 구현마다 달라지는 요소가 줄어 호환성이 오히려 높아진다.
- 실행 시간 바인딩 위주의 언어는 번역 시간 바인딩 위주의 언어보다 융통성이 높다.
ㄴ. Java에서 상속받은 메소드(method)를 재정의하여 사용
ㄷ. C에서 1+1.0을 타입 오류 없이 계산
ㄹ. Java에서 1.0+1.0과 "a"+"b"의 +가 피연산자(operand)의 타입에 따라 다르게 계산
ㅁ. Java에서 PrintStream 클래스의 println 메소드 사용
오버로딩에 해당하는 것은 + 연산자의 타입별 계산과 println 메소드이다.
오버로딩은 같은 이름의 연산자·함수가 피연산자나 인자의 타입에 따라 서로 다른 정의로 선택되는 임시(ad hoc) 다형성이다. println 은 int, double, String 등 매개변수 타입별로 여러 메소드가 정의되어 있다.
- C++ 템플릿은 하나의 정의를 여러 타입에 적용하는 매개변수 다형성이다.
- 상속받은 메소드의 재정의는 오버라이딩으로 서브타입 다형성에 해당한다.
- C에서 1+1.0 이 오류 없이 계산되는 것은 정수를 실수로 자동 변환하는 강제 변환(coercion)이다.
#include <stdio.h>
void main() {
short x[2][2] = {{1,2},{3,4}};
short *px[2]; //포인터 배열
short **ppx; //포인터-포인터 변수
px[0] = x[0]; px[1] = x[1];
ppx = px;
printf("%10u %10u %10u \n", px[0], px[1], ppx);
printf("%10u %10u %10u \n", px[0]+1, px[1]+1, ppx+1);
printf("%10u %10u \n", *(++px[0]), *(++ppx));
}
| 주소 | 저장 값 | 변수 | 구분 |
|---|---|---|---|
| 100 | 1 | x[0][0] | 2차원 배열 |
| 102 | 2 | x[0][1] | 2차원 배열 |
| 104 | 3 | x[1][0] | 2차원 배열 |
| 106 | 4 | x[1][1] | 2차원 배열 |
| 108 | 100 | px[0] | 포인터 배열 |
| 112 | 104 | px[1] | 포인터 배열 |
| 116 | 108 | ppx | 포인터-포인터 변수 |
102 106 112
2 104
102 106 112
1 100
101 105 109
2 104
101 105 109
1 100
출력은 첫 줄 100 104 108, 둘째 줄 102 106 112, 셋째 줄 2 104이다.
포인터에 1을 더하면 가리키는 자료형의 크기만큼 주소가 증가한다. px[0], px[1]은 short*(2바이트)라 2씩, ppx는 short**로 포인터(그림상 4바이트)를 가리키므로 4씩 증가한다.
첫 줄은 px[0]=100, px[1]=104, ppx=108이다.
둘째 줄은 100+2=102, 104+2=106, 108+4=112이다.
셋째 줄에서 ++px[0]은 px[0]을 102로 바꾸므로 *(102)=2이고, ++ppx는 ppx를 112로 바꾸므로 *(112)인 px[1]의 값 104가 출력된다.
- 둘째 줄을 101 105 109로 본 것은 포인터 연산을 바이트 단위 정수 덧셈으로 잘못 계산한 것이다.
- 셋째 줄을 1 100으로 본 것은 전위 증가(++)가 역참조보다 먼저 적용된다는 점을 놓친 것이다.
begin정적영역규칙 동적영역규칙
boolean b := true;
procedure p
begin
print(b); -------- ㉠
end p;
begin
boolean b := false;
call p;
end;
end;
정적 영역 규칙에서는 true, 동적 영역 규칙에서는 false 가 출력된다.
정적 영역은 p 가 선언된 위치를 감싸는 블록에서 b 를 찾으므로 바깥 블록의 b = true 를 쓴다.
동적 영역은 호출 순서를 거슬러 찾으므로 p 를 호출한 내부 블록의 b = false 를 쓴다.
- 둘 다 true 로 본 결과: 동적 영역에서 호출자의 지역 변수가 먼저 보인다는 점을 놓쳤다.
- 둘 다 false 로 본 결과: 정적 영역은 호출 위치와 무관하게 선언 위치로 결정된다.
- 정적 false, 동적 true 는 두 규칙을 서로 바꾼 것이다.
public class C {
private static int num = 0;
protected static int get() {
return num;
}
private static void add() {
num++;
}
C() {
C.add();
}
public static void main(String args[]) {
for (int i=0; i<10; ++i)
new C();
System.out.println("The Value is " + C.get());
}
}출력은 The Value is 10 이다.
num 은 static 이라 모든 객체가 하나의 변수를 공유한다. 생성자가 호출될 때마다 add() 로 num 이 1 씩 증가하고, 루프에서 객체가 열 개 생성되므로 num 은 10 이 된다.
- 1 은 num 이 객체마다 따로 있는 인스턴스 변수라고 본 경우다.
- 0 은 생성자에서 add() 가 호출되지 않는다고 본 경우다. private 메소드도 같은 클래스 안에서는 호출할 수 있다.
- 9 는 루프 횟수를 하나 적게 센 경우로, i 는 0 부터 9 까지 열 차례 반복한다.
옳지 않은 것은 명령형 언어가 정확성 증명이 비교적 용이하다는 설명이다.
명령형 언어는 배정문으로 변수 상태를 계속 바꾸는 부작용이 있어 프로그램 상태를 추적하기 어렵고, 정확성 증명이 함수형·논리형보다 어렵다.
- 논리형 언어는 사실과 규칙을 선언하고 추론으로 답을 구하므로 제어문 없이도 프로그래밍할 수 있다.
- 순수 함수형 언어는 변수와 배정문 없이 함수 적용과 재귀로 계산한다.
- 객체지향 언어는 실세계 객체의 상호작용을 반영하려는 데서 출발해 재사용성과 수정 용이성을 높인다.
T → F - T | F
F → 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9
주어진 수식 : 3 - 2 * 5 - 2 - 1
주어진 수식의 계산 결과는 4 이다.
E → T * E 에서 * 가 위쪽에 있으므로 - 가 * 보다 우선순위가 높고, 두 규칙 모두 오른쪽 재귀이므로 우결합이다.
따라서 수식은 (3 - 2) * (5 - (2 - 1)) 로 묶인다.
3 - 2 = 1, 5 - (2 - 1) = 4 이므로 1 × 4 = 4 이다.
- -10 은 * 를 먼저 계산하는 일반적인 우선순위를 적용한 값이다.
- 2 는 뺄셈을 좌결합으로 계산해 1 × (5 - 2 - 1) 로 본 값이다.
- -5 는 이 문법이 만드는 파스트리로는 나올 수 없는 값이다.