옳은 설명은 쓰레기 수집을 지원하는 언어에서는 허상 포인터 문제가 발생하지 않는다는 것이다.
쓰레기 수집 언어는 프로그래머가 직접 기억장소를 해제하지 않고, 더 이상 참조되지 않는 객체만 시스템이 회수하므로 해제된 공간을 가리키는 포인터가 생기지 않는다.
- 프로그램 시작 시 전체 메모리 크기가 결정되는 것은 정적 할당의 특징이며, 동적 할당은 실행 중에 필요한 만큼 요청한다.
- 동적으로 할당되는 기억장소는 스택의 활성화 레코드가 아니라 힙(heap) 영역에 배정된다.
- C 언어는 쓰레기 수집을 쓰지 않고 malloc/free 로 프로그래머가 명시적으로 관리한다.
옳지 않은 설명은 Java가 클래스의 다중상속을 허용하며 implements를 쓴다는 것이다.
Java는 클래스의 단일 상속만 허용하고(extends), implements 는 여러 인터페이스를 구현할 때 쓰는 예약어이다.
- Java가 상속을 허용하고 extends 예약어를 쓰는 것은 옳다.
- C++은 다중상속을 허용하며 여러 상위클래스를 콤마로 나열한다.
- C++에서 하위클래스는 콜론 뒤에 상위클래스를 적어 상속한다.
public class Animal {
private int legs = 4;
String name = "동물";
public void walk() {
System.out.println(name + "(이)가 걸었습니다.");
}
}
public class Lion extends Animal {
String name = "사자";
public void walk() {
System.out.println(name + "가 걸었습니다.");
}
}이 프로그램에 사용되지 않은 특성은 오버로딩이다.
오버로딩은 같은 이름에 매개변수 목록이 다른 메소드를 여러 개 정의하는 것인데, 코드에는 그런 메소드가 없다. Lion 의 walk() 는 상위 클래스와 시그니처가 같은 재정의이다.
- legs 를 private 으로 선언해 외부 접근을 막았으므로 캡슐화가 쓰였다.
- Lion 이 extends Animal 로 선언되었으므로 상속이 쓰였다.
- 상위 클래스의 walk() 를 하위 클래스에서 같은 형태로 다시 정의했으므로 오버라이딩이 쓰였다.
애플릿의 생명주기는 init() → start() → stop() → destroy() 순서이다.
init() 으로 한 번 초기화되고, start() 로 실행이 시작되며, 페이지를 벗어나면 stop(), 애플릿이 제거될 때 destroy() 가 호출된다.
- service() 는 서블릿이 요청을 처리하는 메소드로 애플릿 생명주기에 속하지 않는다.
- start() → run() → stop() 흐름은 스레드 실행과 관련된 것으로, 애플릿 생명주기의 초기화와 소멸 단계가 빠져 있다.
- run() 과 paint() 가 끼어든 순서는 애플릿 생명주기 메소드의 호출 순서가 아니다.
class SuperClass {
int a, b;
SuperClass() {
a=1;
b=1;
}
SuperClass(int a, int b) {
this.a = a;
this.b = b;
}
}
class SubClass extends SuperClass {
int c;
SubClass() {
c=1;
}
SubClass(int a, int b, int c) {
super(a, b);
this.c = c;
}
}
public class Test {
public static void main(String[] args) {
SubClass o1 = new SubClass();
SubClass o2 = new SubClass(1, 2, 3);
System.out.println("a="+o1.a+", b="+o1.b+", c="+o1.c);
System.out.println("a="+o2.a+", b="+o2.b+", c="+o2.c);
}
}a=1, b=1, c=1
a=1, b=2, c=3
a=1, b=1, c=1
a=1, b=2, c=3
출력은 a=1, b=1, c=1 과 a=1, b=2, c=3 두 줄이다.
o1 을 만드는 SubClass() 생성자는 첫 줄에서 상위 클래스의 기본 생성자 SuperClass() 를 자동으로 호출하므로 a=1, b=1 이 되고 이어 c=1 이 된다.
o2 는 super(1, 2) 로 a=1, b=2 가 설정된 뒤 c=3 이 대입된다.
- 두 줄 모두 1, 1, 1 이 되려면 o2 의 인자가 무시되어야 하므로 틀리다.
- 첫 줄이 1, 2, 3 이 되려면 o1 이 인자 있는 생성자로 만들어져야 하므로 틀리다.
- 두 줄 모두 1, 2, 3 인 경우도 o1 의 기본 생성자 결과와 맞지 않는다.
<A> ::= 0<A> | 1<B>
<B> ::= 1<B> | 0
생성되지 않는 문장은 01100이다.
<B> 는 1을 0개 이상 반복한 뒤 0 하나로 끝나는 문자열만 만든다. 0으로 시작하면 S → 0<B> 이므로 나머지가 1…10 꼴이어야 하는데, 1100 은 0이 두 개라 <B> 로 만들 수 없다.
- 0110 은 0 뒤에 <B> 가 110 을 만들어 생성된다.
- 1110 은 1 뒤에 <A> → 1<B>, <B> 가 10 을 만들어 생성된다.
- 100110 은 1 뒤에 <A> 가 0을 두 번 붙이고 1<B> 로 넘어가 <B> 가 10 을 만들어 생성된다.
○ E : 한 원소의 크기
○ LB1, LB2 : 행의 하한 값, 열의 하한 값
○ UB2 : 열의 상한 값
○ S : 한 행의 크기로 UB2 - LB2 + 1
○ base : 주 기억 장소에서 배열의 시작 주소
행우선 저장에서 주소는 이다.
B(i, j) 앞에는 완전한 행이 (i − LB1)개 있고 각 행은 S개 원소이며, 같은 행 안에서 앞에 (j − LB2)개 원소가 있다. 이 원소 개수에 원소 크기 E 를 곱해 시작 주소에 더한다.
- 열 인덱스에 행 크기 S 를 곱하고 하한 값을 더한 식은 열우선 형태인 데다 오프셋을 오히려 늘리므로 틀리다.
- 행 인덱스에 열 하한을, 열 인덱스에 행 하한을 더한 식은 하한의 짝이 뒤바뀌었고 빼야 할 하한을 더해 틀리다.
- (j − LB2)에 S 를 곱하는 식은 열 오프셋에 행 크기를 곱한 것으로 행우선 주소 계산이 아니다.
int i, j, n = 0;
for (i = 0; i < 10; i++) {
for (j = 0; j < 10; j++) {
if (j > 5) continue;
n++;
}
if (i > 6) break;
}
실행 후 n 의 값은 48이다.
안쪽 루프는 j 가 6 이상이면 continue 로 n++ 를 건너뛰므로 j = 0~5 의 여섯 차례만 n 이 증가한다.
바깥 루프의 break 는 안쪽 루프가 끝난 뒤 검사되므로 i = 0~7 의 여덟 차례 반복이 모두 수행되고 i = 7 에서 멈춘다.
- 30 은 바깥 루프가 다섯 차례만 돈다고 센 값이다.
- 36 은 바깥 루프가 여섯 차례만 돈다고 센 값이다.
- 42 는 i = 7 에서 안쪽 루프가 실행되기 전에 break 된다고 본 값으로, break 검사가 안쪽 루프 뒤에 있다는 점을 놓친 결과이다.
○ +가 *보다 더 높은 우선순위(precedence)를 갖는다.
○ +와 *는 각각 덧셈과 곱셈 연산자로서 결합 순서(associativity)는 우측 우선(right associative)이다.
○ +와 *의 피연산자 자료형이 실수와 정수로 서로 다르면, 실수를 정수로 바꾸는 축소 변환(narrowing conversion)이 실수 피연산자에 대하여 자동으로 적용된다.
○ 실수에서 정수로의 자료형 변환에는 버림이 사용된다.
주어진 원칙으로 계산하면 결과는 25이다.
+ 가 * 보다 우선하므로 식은 (1 + 4) * (0.5 + 2.5 + 3) 으로 묶이고, + 는 우측 결합이므로 뒤쪽은 0.5 + (2.5 + 3) 순서로 계산한다.
2.5 + 3 : 2.5 를 정수로 버림해 2 + 3 = 5
0.5 + 5 : 0.5 를 정수로 버림해 0 + 5 = 5
1 + 4 = 5
5 * 5 = 25
- 8.5 는 일반 수학 원칙(* 우선, 변환 없음)으로 계산한 값이다.
- 30 은 축소 변환 없이 0.5 + 2.5 + 3 = 6 을 실수로 계산해 5 × 6 으로 얻은 값이다.
- 21 은 주어진 우선순위·결합 순서·축소 변환 원칙을 모두 적용한 결과와 맞지 않는다.
(1) int *x, *y, *z;
(2) x = (int *) malloc(sizeof(int));
(3) *x = 1;
(4) z = (int *) malloc(sizeof(int));
(5) *z = 5;
(6) y = x;
(7) *y = 2;
(8) z = y;
(9) free(x);
옳지 않은 설명은 z = y 수행 후 *x와 *y의 별명 현상이 종료된다는 것이다.
z = y 는 z 만 바꿀 뿐 x 와 y 는 여전히 같은 공간을 가리키므로 별명은 유지되고, 오히려 z 까지 세 포인터가 같은 공간을 가리키게 된다.
- y = x 수행 뒤 x 와 y 가 같은 기억장소를 가리키므로 별명 현상이 생긴다.
- z = y 수행 뒤 z 가 처음 할당받은 공간(값 5)은 아무도 가리키지 않아 쓰레기가 된다.
- free(x) 수행 뒤 같은 공간을 가리키던 y, z 는 해제된 공간을 가리키는 허상 포인터가 된다.
옳지 않은 설명은 정적 타입 바인딩 언어는 재귀 호출을 수행할 수 없다는 것이다.
재귀 호출 가능 여부는 타입 바인딩이 아니라 기억장소 할당 방식(스택 기반 활성화 레코드)에 달려 있다. C, Java 처럼 정적 타입 바인딩 언어도 재귀를 지원한다.
- 정적 타입 바인딩은 컴파일 시 타입이 확정되어 실행 중 타입 검사가 필요 없으므로 수행 속도가 빠르다.
- 동적 타입 바인딩은 실행 중 변수에 다른 타입의 값을 담을 수 있어 융통성이 크다.
- 동적 타입 바인딩 언어는 실행 시 타입 정보를 다뤄야 하므로 대부분 인터프리터로 구현된다.
옳지 않은 설명은 객체지향 프로그래밍의 기본 단위가 함수라는 것이다.
객체지향 프로그래밍의 기본 단위는 데이터와 연산을 묶은 객체(클래스)이며, 함수 중심 구성은 절차적 프로그래밍의 특징이다.
- 객체지향은 추상 데이터 타입에 상속과 동적 바인딩을 더한 것으로 설명된다.
- 상속을 통해 기존 클래스를 재사용하므로 소프트웨어 재사용성이 향상된다.
- 상속은 클래스 사이에 종속성을 만들어 추상 데이터 타입의 독립성을 일부 훼손하는 측면이 있다.
변수 선언의 목적이 아닌 것은 변수의 위치 지정이다.
변수가 놓일 실제 메모리 위치(주소)는 프로그래머가 선언으로 정하지 않고 컴파일러·실행 시스템이 결정한다.
- 선언된 자료형에 따라 변수가 차지할 크기가 정해진다.
- 선언 위치에 따라 변수를 참조할 수 있는 영역(scope)이 정해진다.
- 선언으로 변수의 자료형을 지정해 허용 연산과 타입 검사를 가능하게 한다.
연관성이 가장 적은 것은 유니코드 지원과 메모리의 효율적 사용이다.
유니코드는 문자당 바이트 수가 ASCII 보다 커서 메모리를 오히려 더 쓰며, 그 목적은 다국어 문자 처리이다.
- 애플릿 지원으로 웹 브라우저에서 실행할 수 있어 웹용 언어로 널리 쓰였다.
- 배열 첨자 범위를 실행 중 검사하므로 경계 이탈 오류를 막는다.
- 가상 기계 위에서 바이트코드를 실행하므로 플랫폼 독립적이라 C 보다 이식성이 높다.
옳은 설명은 기억장소 할당이 실행에 필요한 변수들의 기억장소를 배정하는 것이라는 것이다.
기억장소 바인딩은 변수에 메모리 공간을 연결하는 것으로, 할당(allocation)은 공간을 배정하고 회수(deallocation)는 그 공간을 사용 가능한 영역으로 되돌리는 것이다.
- Java 에서 static 으로 선언한 변수는 스택-동적 변수가 아니라 정적 변수이다.
- 정적 변수는 실행시간 스택이 아니라 실행 전에 고정된 정적 영역에 할당된다.
- 기억장소 회수는 주기억장치에서 보조기억장치로 옮기는 것이 아니라 바인딩된 공간을 해제하는 것이다.
(단, 정수형 변수는 4바이트가 할당된다고 가정한다)
int a, *i_ptr; /* a 변수의 저장 주소는 1000번지 */
char b, *c_ptr; /* b 변수의 저장 주소는 2000번지 */
i_ptr = &a;
c_ptr = &b;
i_ptr = i_ptr + 2;
c_ptr = c_ptr + 2;
실행 후 값은 i_ptr : 1008, c_ptr : 2002 이다.
포인터에 정수를 더하면 가리키는 자료형 크기 단위로 주소가 증가한다.
i_ptr :
c_ptr :
- 둘 다 2씩 증가한 값은 자료형 크기를 무시하고 바이트 단위로 더한 것이다.
- 둘 다 8씩 증가한 값은 char 포인터까지 4바이트 단위로 계산한 것이다.
- 둘 다 4씩 증가한 값은 두 포인터를 같은 폭으로 움직여 자료형별 크기 차이를 반영하지 않은 것이다.
global variable int x = 0;세 개의 프로세스가 모두 종료된 후에 공유변수 x가 가질 수 없는 값은?
process P1
local variable int y = 0;
y := x;
x := y + 1;
endprocess P1
process P2
local variable int y = 0;
y := x;
x := y + 2;
endprocess P2
process P3
local variable int y = 0;
y := x;
x := y + 4;
endprocess P3
main
start {P1, P2, P3}
endmain
x 가 가질 수 없는 값은 0이다.
각 프로세스의 마지막 동작은 x := y + k (k 는 1, 2, 4) 이고 y 는 0 이상이므로, 마지막으로 x 에 쓴 프로세스가 누구든 x 는 최소 1 이상이 된다.
- 4 는 P3 가 처음에 0 을 읽어 두고 다른 프로세스보다 나중에 0 + 4 를 쓰면 나온다.
- 6 은 P1, P2 가 모두 0 을 읽고 P2 가 나중에 2 를 쓴 뒤, P3 가 2 를 읽어 2 + 4 를 쓰면 나온다.
- 7 은 세 프로세스가 차례로 읽고 써서 1 + 2 + 4 가 모두 반영되면 나온다.
E -> E ⓐ T
| T
T -> T ⓑ F
| F
F -> id
| ( E )
옳지 않은 설명은 ⓐ가 ⓑ보다 우선순위가 높다는 것이다.
파스 트리에서 더 아래(시작 기호에서 먼) 단계에 있는 연산자가 먼저 계산되므로, T 단계의 ⓑ가 E 단계의 ⓐ보다 우선순위가 높다.
- 괄호는 가장 아래 단계인 F 에서 처리되므로 ⓐ보다 우선순위가 높다.
- T → T ⓑ F 는 좌측 재귀이므로 ⓑ는 좌측 결합이다.
- 우선순위와 결합 순서가 계층으로 정해져 한 문장에 파스 트리가 하나뿐이므로 모호하지 않다.
#include<iostream.h>
void inc_counter1(int *counter)
{
++(*counter);
}
void inc_counter2(int &counter)
{
++counter;
}
void inc_counter3(int counter)
{
++counter;
}
void main()
{
int a_count = 0;
inc_counter1(&a_count);
inc_counter2(a_count);
inc_counter3(a_count);
cout<<a_count<<'\n';
}
출력 결과는 2이다.
포인터로 넘긴 inc_counter1 과 참조로 넘긴 inc_counter2 는 원본 a_count 를 1씩 증가시키고, 값 전달인 inc_counter3 은 복사본만 증가시킨다.
0 → 1 (포인터) → 2 (참조) → 2 (값 전달, 변화 없음)
- 0 은 포인터·참조 전달도 원본을 바꾸지 못한다고 본 값이다.
- 1 은 포인터 전달과 참조 전달 중 하나만 원본에 반영된다고 본 값이다.
- 3 은 값 전달 함수까지 원본을 바꾼다고 본 값이다.
#include<stdio.h>
void func(void)
{
static int a = 200;
int b = 1;
printf("a=%d, b=%d \n", ++a, ++b);
printf("a=%d, b=%d \n", a++, b++);
}
void main()
{
int i;
for(i = 1; i <= 3; i++) func();
}
a=201, b=2
a=203, b=2
a=203, b=2
a=205, b=2
a=205, b=2
a=201, b=2
a=201, b=2
a=201, b=2
a=201, b=2
a=201, b=2
a=202, b=3
a=203, b=2
a=204, b=3
a=205, b=2
a=206, b=3
a=202, b=3
a=202, b=1
a=204, b=3
a=204, b=1
a=206, b=3
출력은 a 가 201, 201, 203, 203, 205, 205, b 는 모두 2 인 여섯 줄이다.
static 변수 a 는 호출 사이에 값이 유지되고 초기화도 한 번만 된다. 지역 변수 b 는 호출마다 1로 다시 초기화된다.
첫 호출 : ++a → 201, ++b → 2 출력 / a++ 는 201 출력 후 202, b++ 는 2 출력
둘째 호출 : 203 과 203 출력 후 a = 204
셋째 호출 : 205 와 205 출력
- a 가 매번 201 로 같은 출력은 static 변수 값이 호출 사이에 유지된다는 점을 무시한 것이다.
- b 가 3 으로 출력되는 경우는 후위 증가 b++ 가 증가 전 값을 출력한다는 점을 무시한 것이다.
- a=200, b=1 로 시작하는 출력은 전위 증가가 증가 후 값을 출력한다는 점을 무시한 것이다.