#include <stdio.h>
void main() {
printf("%d\n", 8 >> 2 ? 2 | 1 : 2 & 1);
}
조건식 8 >> 2 가 참이 되어 2 | 1 = 3이 출력된다.
시프트·비트 연산자는 조건 연산자(?:)보다 우선순위가 높으므로 식은 (8 >> 2) ? (2 | 1) : (2 & 1)로 묶인다. 8을 오른쪽으로 2비트 밀면 2(0이 아님)이므로 참 쪽 식이 선택된다.
- 0: 거짓 쪽 식 2 & 1의 값으로, 조건이 참이라 선택되지 않는다.
- 1: 비트 OR(|)를 논리 OR(||)로 혼동해 참 값 1이 나온다고 본 값이다.
- 2: 조건식 8 >> 2 자체의 값일 뿐 출력되는 값이 아니다.
C 언어의 int 크기는 고정되어 있지 않다 — 표준은 최소 범위만 정하고 실제 크기는 컴파일러·플랫폼에 따라 달라진다(16비트 환경에서는 2바이트 등).
반면 Java는 언어 명세로 int를 4바이트로 고정해 플랫폼 독립성을 보장한다.
- 문자 타입: C의 char는 1바이트로 ASCII 코드값을, Java의 char는 2바이트 Unicode 코드값을 저장한다는 설명은 옳다.
- 논리 타입: Java의 boolean은 int 등 수치 타입과 상호 변환(캐스팅)이 허용되지 않는다는 설명은 옳다.
- 실수 타입: float와 double이 두 언어 모두의 실수 타입이라는 설명은 옳다.
class Super {
Super() {
System.out.print("A");
}
}
public class Sub extends Super {
Sub() {
System.out.print("B");
}
static {
System.out.print("C");
}
public static void main(String[] args) {
System.out.print("D");
new Sub();
}
}출력은 CDAB이다.
main이 있는 Sub 클래스가 로딩될 때 static 초기화 블록이 main보다 먼저 실행되어 C가 출력되고, 이어 main에서 D가 출력된다.
new Sub()에서는 자식 생성자 첫 줄에 암묵적 super()가 있어 부모 생성자가 먼저 실행되므로 A 다음 B가 출력된다.
- CDBA: 부모 생성자가 자식 생성자 본문보다 늦게 실행된다고 본 순서다.
- DABC, DCBA: static 블록이 main 실행 전, 클래스 로딩 시점에 수행된다는 점을 놓친 순서다.
참조형 변수는 객체 자체가 아니라 객체를 가리키는 참조(주소)를 저장한다.
객체는 힙에 생성되고 변수에는 그 객체에 접근하는 참조값만 담기므로, 참조형 변수끼리 대입하면 객체가 복사되지 않고 같은 객체를 함께 가리키게 된다.
- 참조형의 종류로 클래스형·인터페이스형·배열형 등이 있다는 설명은 옳다.
- null은 어떤 객체도 참조하지 않는 상태를 뜻한다는 설명은 옳다.
- 참조형 변수를 통해 객체의 데이터에 접근하고 메소드를 호출한다는 설명은 옳다.
#include <stdio.h>
void main() {
int i, j, s = 0;
for (i = 1; i < 10; i++) {
for (j = 1; j < 10; j++) {
if (j%2 == 0) continue;
if (i%3 == 0) continue;
if (i%4 == 0) break;
s++;
}
}
printf("%d\n", s);
}
s는 20이 된다.
안쪽 루프는 j가 짝수면 건너뛰므로 j = 1, 3, 5, 7, 9의 5회만 검사된다. i가 3의 배수면 매번 continue되고, i가 4의 배수면 첫 홀수 j에서 break되어 s가 증가하지 않는다.
- i = 3, 6, 9: 3의 배수 조건에 걸려 continue — 증가 0
- i = 4, 8: 첫 홀수 j에서 break — 증가 0
- i = 1, 2, 5, 7: 홀수 j 5개마다 증가 — 각 5
따라서 s = 4 × 5 = 20이다.
#include <stdio.h>
int f(int a) {
return (a + 1.5);
}
void main() {
float x = 3.5;
int y = 2;
float z = 1.0;
z += x + y * 12.5 + f(x);
printf("%.1f\n", z);
}
출력은 33.5이다.
f(x) 호출 시 실인수 3.5가 int 매개변수로 넘어가며 3으로 절삭되고, 3 + 1.5 = 4.5가 int 반환형 때문에 다시 4로 절삭된다.
- y * 12.5 = 25.0
- x + 25.0 + f(x) = 3.5 + 25.0 + 4 = 32.5
- z += 32.5 → 1.0 + 32.5 = 33.5
절삭을 모두 무시하면 34.5, 반환값 절삭만 놓치면 34.0이라는 잘못된 값이 나온다.
모니터 안에서는 한 번에 하나의 프로세스만 활성화될 수 있다 — 이 상호배제가 모니터의 핵심이다.
모니터는 공유 데이터와 이를 다루는 프로시저를 하나로 묶은 언어 수준의 구성체로, 진입 자체를 상호배제로 보장하고 조건변수의 wait/signal로 실행 순서를 동기화한다.
- 프로그래밍 언어 수준에서 세마포어와 유사한 동기화 기능을 제공한다는 설명은 옳다.
- 동기화를 위해 조건변수를 제공한다는 설명은 옳다.
- 지역 변수, 프로시저, 초기화 코드로 구성된다는 설명은 옳다.
#include <stdio.h>
int f(int x, int y) {
int z;
z = ++x + y--;
printf("%d ", z);
return x+y;
}
void main() {
int x = 3, y = 4, z;
z = f(x, y);
{
int x = 5;
printf("%d ", z);
z = f(x, y);
}
printf("%d ", z);
}
출력은 8 7 10 9이다.
C는 값에 의한 전달이므로 f 안의 ++x, y--는 main의 x, y를 바꾸지 않는다. 내부 블록의 x = 5는 바깥 x를 가리지만 y는 그대로 4다.
- 첫 호출 f(3, 4): z = 4 + 4 = 8 출력, 이후 x = 4, y = 3이므로 7 반환
- 블록 안: z = 7 출력
- 둘째 호출 f(5, 4): z = 6 + 4 = 10 출력, 이후 x = 6, y = 3이므로 9 반환
- 마지막: z = 9 출력
후위 y--는 덧셈에는 감소 전 값이, 반환식에는 감소된 값이 쓰인다는 점이 핵심이다.
#include <stdio.h>
void main() {
int x[4][3] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12};
int (*p)[3];
int *pp[3];
p = &x[1];
pp[0] = x[2];
printf("%d %d %d %d\n", (*p)[0], p[1][0], *pp[0], **(p+1));
}
값이 다른 것은 (*p)[0]으로 4이고, 나머지는 모두 7이다.
x[4][3]은 행 단위로 {1,2,3}, {4,5,6}, {7,8,9}, {10,11,12}가 저장된다. p는 원소 3개짜리 배열을 가리키는 포인터로 x[1]행을 가리키고, pp는 int 포인터 3개의 배열로 pp[0]이 x[2]행의 첫 원소를 가리킨다.
- (*p)[0]: x[1][0] = 4
- p[1][0]: p에서 한 행 뒤인 x[2][0] = 7
- *pp[0]: x[2][0] = 7
- **(p+1): p+1이 x[2]행을 가리키므로 x[2][0] = 7
#include <iostream>
#include <string.h>
using std::cout;
using std::endl;
class A {
char *str;
public:
A() { str = NULL; }
( ㉠ )
A(char *ss) {
str = new char[strlen(ss)+1];
strcpy(str, ss);
}
void set(char *cc) { strcpy(str, cc); }
void show() { cout << str << endl; }
};
void main() {
A a("AAAA");
A b = a;
a.set("BBBB");
a.show();
b.show();
}
BBBB
AAAA
A(A a) {
str = new char[strlen(a.str)+1];
strcpy(str, a.str);
}A(A *a) {
str = new char[strlen(a->str)+1];
strcpy(str, a->str);
}A(A &a) {
str = new char[strlen(a.str)+1];
strcpy(str, a.str);
}A(char *a) {
str = new char[strlen(a)+1];
strcpy(str, a);
}필요한 것은 참조로 받는 복사 생성자 A(A &a)로, 새 메모리를 할당해 문자열을 복사하는 깊은 복사를 수행한다.
A b = a;는 복사 생성자를 호출한다. 사용자 정의가 없으면 기본 복사 생성자가 포인터 str만 복사하는 얕은 복사를 해 a.set 이후 b도 BBBB를 출력한다. 깊은 복사를 하면 b는 AAAA를 유지한다.
- A(A a): 값으로 받으면 인수 전달 자체에 복사 생성자가 필요해 무한 재귀가 되므로 허용되지 않는다(컴파일 오류).
- A(A *a): 포인터를 받는 일반 생성자일 뿐 복사 생성자가 아니어서 A b = a;에는 기본 얕은 복사가 쓰인다.
- A(char *a): 같은 시그니처의 생성자가 이미 있어 중복 정의 오류가 난다.
C++ 클래스의 멤버 변수는 static으로 선언할 수 있다 — 정적 멤버 변수는 모든 객체가 공유하는 클래스 단위 변수다.
정적 멤버 변수는 클래스 안에서 선언하고 보통 클래스 밖에서 정의·초기화하며, 객체 없이 클래스명::변수명으로도 접근할 수 있다.
- 클래스로부터 만들어진 인스턴스를 객체라 한다는 설명은 옳다.
- 소멸자는 객체가 소멸될 때 자동 호출된다는 설명은 옳다.
- 부모의 멤버 함수를 자식에서 재정의하는 것을 오버라이딩이라 한다는 설명은 옳다.
표현할 수 없는 것은 adaddada이다.
a(da|ad|a)*는 첫 글자 a 뒤에 da, ad, a 조각을 반복해 이어 붙인 문자열이다. 따라서 d가 나오는 자리는 반드시 da 또는 ad 조각의 일부여야 한다.
- adaaddaa = a·da·ad·da·a 로 분해된다.
- adadaaaadada = a·da·da·a·a·a·da·da 로 분해된다.
- adadaaddaaa = a·da·da·ad·da·a·a 로 분해된다.
- adaddada: a·da 뒤에 남는 ddada가 d로 시작하므로 da 조각이어야 하지만 둘째 글자도 d라 어떤 조각으로도 맞출 수 없다.
class Parent { }
class Child extends Parent { }
public class Test {
public static void main(String[] args) {
( ㉠ )
}
}ⓐ
Parent p = new Parent();ⓑ
Child c;
c = p;
Parent p = new Parent();ⓒ
Child c;
c = (Child) p;
Parent p = new Child();ⓓ
Child c;
c = (Child) p;
Parent p;
Child c = new Child();
p = c;
오류·예외 없이 실행되는 것은 ⓒ와 ⓓ이다.
자식 객체를 부모 타입으로 받는 업캐스팅은 자동으로 되지만, 부모 타입을 자식 타입으로 바꾸는 다운캐스팅은 명시적 캐스트가 필요하고 실제 객체가 자식 타입일 때만 성공한다.
- ⓐ: Parent 타입을 캐스트 없이 Child 변수에 대입해 컴파일 오류가 난다.
- ⓑ: 캐스트로 컴파일은 되지만 실제 객체가 Parent라 실행 중 ClassCastException이 발생한다.
- ⓒ: 실제 객체가 Child이므로 다운캐스팅이 성공한다.
- ⓓ: Child 객체를 Parent 변수에 대입하는 업캐스팅이라 문제없다.
<stmt_list> → <stmt> | <stmt>; <stmt_list>
<stmt> → <var>=<expression>
<var> → A | B | C | D
<expression> → <var>+<var> | <var>-<var> | <var>
유도될 수 없는 것은 begin A=B+C+D end이다.
<expression>은 <var>+<var>, <var>-<var>, <var> 중 하나뿐이라 피연산자가 최대 2개다. 재귀 규칙이 없으므로 B+C+D처럼 변수 3개를 잇는 식은 만들 수 없다.
- begin A=B+C end: 문장 하나, 식은 <var>+<var>로 유도된다.
- begin A=B+C; B=C+D end: <stmt>; <stmt_list>로 두 문장을 잇고 각 식이 <var>+<var>이다.
- begin A=B+C; C=D end: 둘째 문장의 식이 <var> 하나로 유도된다.
#include <iostream>
using std::cout;
using std::endl;
void swap1(int *a, int *b) {
int temp = *a; *a = *b; *b = temp;
}
void swap2(int &a, int &b) {
int temp = a; a = b; b = temp;
}
void main() {
int c = 10, d = 30;
swap1(&c, &d);
cout << c << " " << d << endl;
swap2(c, d);
cout << c << " " << d << endl;
}
10 30
30 10
10 30
30 10
출력은 첫 줄 30 10, 둘째 줄 10 30이다.
swap1은 주소를 받아 *a, *b로 원본을 바꾸고(포인터 전달), swap2는 참조 매개변수로 원본 자체를 바꾼다(참조 전달). 두 함수 모두 실인수 c, d를 실제로 교환한다.
- swap1(&c, &d) 후: c = 30, d = 10
- swap2(c, d) 후: 다시 교환되어 c = 10, d = 30
둘 중 하나를 값 전달로 착각하면 교환이 일어나지 않은 것으로 계산하게 된다. 두 방식 모두 원본을 수정한다는 점이 핵심이다.
import java.util.*;
public class GenericSuperTest {
public static void main(String args[]) {
Vector<String> names;
Vector<Integer> scores;
Vector<Object> obj;
Vector<?> wild;
names = new Vector<String>();
scores = new Vector<Integer>();
scores = names; // ㉠
obj = (Vector<Object>) names; // ㉡
wild = names; // ㉢
names = (Vector<String>) wild; // ㉣
scores = (Vector<String>) wild; // ㉤
}
}
컴파일 오류는 ㉠, ㉡, ㉤에서 발생한다.
제네릭은 불공변(invariant)이라 Vector<String>, Vector<Integer>, Vector<Object>는 서로 대입·캐스트할 수 없는 별개 타입이다. 반면 와일드카드 Vector<?>는 모든 Vector<T>를 받을 수 있다.
- ㉠: Vector<String>을 Vector<Integer> 변수에 대입 — 호환되지 않는 타입으로 오류
- ㉡: Vector<String>을 Vector<Object>로 캐스트 — 변환할 수 없는 타입으로 오류
- ㉢: Vector<?>에 Vector<String> 대입 — 허용
- ㉣: Vector<?>를 Vector<String>으로 캐스트 — 비검사(unchecked) 경고만 있고 컴파일됨
- ㉤: 캐스트 결과인 Vector<String>을 Vector<Integer> 변수에 대입 — 오류
void f() {
static int n = 0;
int i = 10, *p, *q;
p = (int *) malloc(sizeof(int));
q = &i;
}포인터 변수 p 자체는 지역 변수이므로 스택에 할당된다 — malloc으로 받은 메모리는 힙이지만, 그 주소를 담는 p는 스택에 있다.
함수 안의 일반 지역 변수(자동 변수)는 스택에, static 지역 변수는 프로그램 실행 내내 유지되는 데이터(정적) 영역에 할당된다.
- n: static으로 선언되어 스택이 아니라 데이터 영역에 할당된다.
- q: i의 주소를 담는 지역 포인터로 힙이 아니라 스택에 할당된다.
- i: 일반 지역 변수이므로 힙이 아니라 스택에 할당된다.
#include <iostream>
using std::cout;
class A {
public:
virtual void p() { cout << "A.p "; }
void q() { cout << "A.q "; }
virtual void r() {
p();
q();
}
};
class B : public A {
public:
void p() { cout << "B.p "; }
};
class C : public B {
public:
void q() { cout << "C.q "; }
void r() {
q();
p();
}
};
void main() {
A *ap = new B;
ap->r();
ap = new C;
ap->r();
}
출력은 B.p A.q C.q B.p이다.
virtual 함수는 포인터가 가리키는 실제 객체 타입으로, 비가상 함수는 호출 코드의 정적 타입으로 결정된다. r은 A에서 virtual이므로 C의 r도 가상 재정의가 된다.
- ap = new B 후 ap->r(): B는 r을 재정의하지 않아 A::r 실행 → p()는 가상이라 B.p, q()는 비가상이라 A.q
- ap = new C 후 ap->r(): C::r 실행 → C 안의 q()는 C::q로 C.q, p()는 C가 상속받은 B::p로 B.p
A::r 안의 q()를 가상처럼 처리하거나 p()를 A의 것으로 처리하면 다른 순서가 나온다. virtual 여부가 바인딩 시점을 가른다.
class A extends RuntimeException { };
class B extends A { };
class Test {
public static void main(String[] args) {
try {
try {
throw new B();
} catch (A x) {
System.out.print("1 ");
throw x;
} finally {
System.out.print("2 ");
}
} catch (B x) {
System.out.print("3 ");
}
}
}출력은 1 2 3이다.
던져진 B 객체는 A의 하위 클래스이므로 안쪽 catch (A x)에 잡혀 1을 출력한 뒤 다시 던져진다. 안쪽 try를 빠져나가기 전 finally 블록이 반드시 실행되어 2가 출력된다.
재던진 예외 객체의 실제 타입은 여전히 B이므로 바깥 catch (B x)에 잡혀 3이 출력된다. 변수 x의 선언 타입이 아니라 실제 객체 타입으로 catch가 결정된다.
- 1 2: 재던진 예외가 A 타입으로 바뀐다고 보아 바깥 catch를 놓친 결과다.
- 2 3: 안쪽 catch (A x)가 하위 타입 B를 잡지 못한다고 본 결과다.
- 3: 안쪽 catch와 finally 실행을 모두 누락한 결과다.
#include <stdio.h>
unsigned int getbits(unsigned x, int p, int n) {
return (x >> (p - n)) & ~(~0 << n);
}
void main() {
unsigned int x = 312, res;
res = getbits(x, 8, 4);
printf("%d\n", res);
}
출력은 3이다.
getbits(x, p, n)는 x를 p−n비트 오른쪽 시프트한 뒤 하위 n비트만 남기는 함수다. ~(~0 << n)은 하위 n비트가 모두 1인 마스크다.
- 312 = 256 + 32 + 16 + 8 → 2진수 100111000
- x >> (8 − 4) = x >> 4 → 10011 (= 19)
- ~(~0 << 4) → 1111 (= 15)
- 10011 & 01111 → 00011 = 3