같은 기억 장소를 여러 멤버가 공유하도록 하는 것이 공용체(union)의 용도다.
공용체는 모든 멤버가 같은 시작 주소를 쓰고 크기는 가장 큰 멤버에 맞춰지며, 구조체는 멤버마다 별도의 기억 장소를 갖는다.
- 배열은 구조체의 멤버가 될 수 있다(예: 문자 배열 멤버).
- 구조체 멤버로 다른 구조체를 둘 수 있다(중첩 구조체). 자기 자신 타입만은 포인터로 둬야 한다.
- 구조체 포인터로 멤버를 참조할 때는 점이 아니라 화살표(->) 연산자를 쓴다. 점 연산자는 구조체 변수에 쓴다.
#include <stdio.h>
typedef struct p {
int x, y;
} PT;
void calcPoint(PT x, PT y, PT z) {
z.x = x.x + y.x;
z.y = x.y + y.y;
}
int main() {
PT p1 = {10,20}, p2 = {30,40}, p3 = {0,0};
calcPoint(p1, p2, p3);
printf("(%d, %d)\n", p3.x, p3.y);
return 0;
}
출력은 (0, 0)이다. C의 구조체 인자는 값에 의한 전달이기 때문이다.
calcPoint 의 매개변수 z 는 p3 의 복사본이므로 z.x, z.y 에 합을 넣어도 main 의 p3 는 바뀌지 않는다.
- (10, 20)은 p1 의 값으로, p3 에 대입되는 경로가 없다.
- (30, 40)은 p2 의 값으로 역시 p3 와 무관하다.
- (40, 60)은 z 에 계산된 합이지만 복사본에만 저장되고 함수 종료와 함께 사라진다. 포인터로 넘겼다면 이 값이 출력된다.
#include <stdio.h>
int main() {
int a;
double c, d;
c = a = 3.5;
d = 3+a/2+c;
printf("Result = %3.1f\n", d);
return 0;
}
출력은 Result = 7.0이다. 정수 변수 대입과 정수 나눗셈에서 소수부가 버려진다.
대입은 오른쪽부터 이뤄져 a = 3.5 에서 a 는 3 이 되고, 그 대입식의 값 3 이 c 에 들어가 c 는 3.0 이다.
a/2 는 정수끼리의 나눗셈이라 1 이다.
- 7.5 는 c 를 3.5 로 보거나 a/2 를 1.5 로 본 경우로, 소수부 절단을 한 곳에서 빠뜨린 값이다.
- 8.0 은 c 를 3.5, a/2 를 1.5 로 보아 두 절단을 모두 무시한 값이다.
포인터 변수 p 의 r-값은 i 의 값이 아니라 i 의 주소이므로 그 설명이 틀렸다.
l-값은 변수가 저장된 위치, r-값은 그 위치에 담긴 값이다. p 에 담긴 값이 i 의 주소이고, i 의 값은 역참조(*p)해야 얻는다.
- 배정문 A := B 는 B 의 r-값을 읽어 A 의 l-값 위치에 저장하므로 옳다.
- Bliss 는 변수 이름이 항상 l-값을 뜻해 값을 얻으려면 점(.) 단항 연산자를 붙이므로 옳다.
- a+b 같은 수식의 결과는 저장 위치가 없는 임시값이라 r-값만 의미가 있으므로 옳다.
추상클래스는 인스턴스를 직접 생성할 수 없으므로, 서브클래스 없이 인스턴스를 만들 수 있다는 설명이 틀렸다.
추상 메소드는 몸체가 없으므로, 이를 모두 구현한 구체 서브클래스를 통해서만 객체를 만들 수 있다.
- 여러 서브클래스가 구현할 공통 인터페이스의 메소드를 선언하는 것이 추상클래스의 목적이므로 옳다.
- 추상클래스 타입 변수로 여러 서브클래스 객체를 다루는 서브타입 다형성을 제공하므로 옳다.
- 서브클래스도 추상클래스이면 추상 메소드 구현을 다시 하위 클래스로 미룰 수 있으므로 옳다.
#include <stdio.h>
#include <stdlib.h>
int main() {
int i, res = 0;
int *ip = (int *) calloc(5, sizeof(int));
for (i = 0; i< 5; i++)
ip[i] += i + 1;
ip = (int *) realloc(ip, 10 * sizeof(int));
for (i = 5; i< 10; i++)
ip[i] = ip[i-5] + i + 1;
for (i = 0; i< 10; i++)
res += ip[i];
printf("%d\n", res);
return 0;
}
출력은 70이다. calloc 은 0 으로 초기화하고, realloc 은 기존 원소 값을 보존한다.
첫 반복 후 ip[0]~ip[4] 는 1, 2, 3, 4, 5 이고 합은 15 이다.
ip[i] = ip[i-5] + i + 1 에 따라 ip[5]~ip[9] 는 7, 9, 11, 13, 15 이고 합은 55 이다.
- 15 는 앞 다섯 원소의 합만 센 값이다.
- 55 는 뒤 다섯 원소의 합만 센 값이다.
#include <stdio.h>
#define COL ( ㉠ )
int main() {
int arr[ ][COL] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
const int ROW = sizeof(arr) / sizeof(int) / COL;
int (*ptr1)[COL] = arr;
int *ptr2[ROW];
int i, res = 0;
for (i = 0; i< ROW; i++) {
ptr2[i] = *(ptr1 + i);
res += *ptr2[i];
}
printf("%d\n", res);
return 0;
}
㉠ 에는 4가 들어간다. 열 수에 따라 행 수와 각 행의 첫 원소가 달라진다.
COL 이 4 이면 초기값 10개가 {1,2,3,4}, {5,6,7,8}, {9,10,0,0} 의 3행이 된다. 원소 수 12 를 COL 로 나눠 ROW 는 3 이고, ptr2[i] 는 i 행의 시작 주소이므로 res 는 각 행 첫 원소의 합이다.
- COL 이 2 이면 5행으로 1+3+5+7+9 = 25 이다.
- COL 이 3 이면 마지막 행이 {10,0,0} 인 4행으로 1+4+7+10 = 22 이다.
- COL 이 5 이면 2행으로 1+6 = 7 이다.
엄격한 타입 언어라고 해서 정적 타입이어야 하는 것은 아니므로 그 설명이 틀렸다.
강한 타입은 모든 타입 오류를 컴파일 중이든 실행 중이든 탐지한다는 뜻이고, 타입 결정 시점과는 별개의 기준이다. Python 처럼 동적 타입이면서 강한 타입인 언어도 있다.
- 타입을 값의 집합과 그 값에 대한 연산의 집합으로 보는 것은 표준 정의다.
- 타입 오류는 연산을 맞지 않는 타입의 값에 적용할 때 생기는 오류이므로 옳다.
- 동적 타입은 변수의 타입이 저장되는 값에 따라 실행 중 바뀔 수 있다는 뜻이고 Python 이 대표적이므로 옳다.
(단, Java에서 static은 정적 필드나 정적 메소드를 정의하기 위한 구문이다)
class A {
protected static int a=0;
protected int b=0;
public static void inc_a() { a++; }
public void inc_b() { b++; }
public void print() {
System.out.println(a+" "+b);
}
}
class B extends A {
public static void inc_a() { a+=2; }
public void inc_b() { b+=2; }
}
public class Test {
public static void main(String[ ] args) {
B y = new B();
A z = new B();
y.inc_a();
y.inc_b();
z.inc_a();
z.inc_b();
z.print();
}
}출력은 3 2이다. 정적 메소드는 변수의 선언 타입으로, 인스턴스 메소드는 실제 객체 타입으로 결정된다.
y.inc_a() 는 B 의 정적 메소드라 a 가 2 가 되고, y.inc_b() 는 y 의 b 만 2 로 만든다.
z 는 A 로 선언됐으므로 z.inc_a() 는 A 의 정적 메소드가 호출되어 a 가 3 이 된다. z.inc_b() 는 동적 바인딩으로 B 의 메소드가 실행되어 z 의 b 가 2 이다. a 는 정적 필드라 모든 객체가 공유한다.
- 4 2 는 z.inc_a() 도 B 의 정적 메소드로 본 값이다. 정적 메소드는 재정의되지 않고 숨겨질 뿐이다.
- b 를 4 로 본 값들은 두 객체가 b 를 공유한다고 착각한 것인데, b 는 인스턴스 필드라 객체마다 따로 있다.
Java 배열은 선언만으로는 메모리가 없고, new 연산자로 할당해야 한다.
int[] a; 는 참조 변수만 만들며, a = new int[5]; 처럼 할당한 뒤에야 원소를 쓸 수 있다. 배열 자체가 힙에 생성되는 객체다.
- 할당 전에는 배열 객체가 없어 원소를 쓸 수 없다(초기화 안 된 지역 변수는 컴파일 오류, null 참조면 NullPointerException).
- String[] 같은 객체 배열은 원소에 참조 값을 저장한다.
- 선언 int[] a; 에는 크기를 쓰지 않으며, 크기는 new 로 생성할 때 정한다.
배열 이름은 상수 주소처럼 취급되어 값을 배정할 수 없으므로 그 설명이 틀렸다.
int a[5]; 에서 a = p; 같은 대입은 컴파일 오류다. 포인터 변수와 달리 배열 이름은 수정 가능한 l-값이 아니다.
- 포인터에는 정수 덧셈·뺄셈, 포인터끼리의 뺄셈·비교 같은 제한된 산술만 허용되므로 옳다.
- p + index 는 index 에 가리키는 타입의 크기를 곱해 주소에 더하므로 옳다.
- 배열 이름은 첫 번째 원소의 주소로 변환되므로 옳다.
#include <stdio.h>
int main() {
int a, b;
a = 8;
b = 12;
printf("a^b = %d\n", a^b);
return 0;
}
출력은 a^b = 4이다. C 의 ^ 는 거듭제곱이 아니라 비트 XOR 연산자다.
8 은 2진수 1000, 12 는 1100 이며, XOR 은 두 비트가 서로 다른 자리만 1 로 만든다.
AND 였다면 8, OR 였다면 12 가 되므로 연산자를 혼동하지 않아야 한다.
#include <stdio.h>
#define MULTIPLY(a, b) (a*b)
int main() {
float f = 100/MULTIPLY(2+3, 4+5);
printf("%.1f\n", f);
return 0;
}
출력은 5.0이다. 매크로는 단순 텍스트 치환이라 인자에 괄호가 없으면 연산 순서가 바뀐다.
MULTIPLY(2+3, 4+5) 는 (2+3*4+5) 로 펼쳐져 곱셈이 먼저 계산된다.
100/19 는 정수 나눗셈이라 5 이고, 이를 float 에 넣어 5.0 이 출력된다. 매크로가 ((a)*(b)) 로 정의됐다면 100/45 로 2.0 이 나왔을 것이다.
C++ 의 프렌드 함수는 다른 클래스의 private 멤버 접근을 허용하는 장치로, 다중 상속 문제 해결과 무관하므로 그 설명이 틀렸다.
다중 상속에서 공통 조상이 중복 상속되는 다이아몬드 문제는 C++ 에서 가상 기초 클래스(virtual 상속)로 해결한다.
- 다중 상속의 상속 그래프는 방향성 비순환 그래프이고, 공통 조상의 메소드가 두 경로 이상으로 상속될 수 있으므로 옳다.
- Java 는 클래스 다중 상속을 막고 인터페이스를 여러 개 구현하게 하므로 옳다.
- Java 의 instanceof 는 객체가 특정 클래스(또는 그 하위) 타입인지 검사하므로 옳다.
#include <iostream>
using namespace std;
class Base {
protected :
int a, b;
public :
void setab(int n, int m) { a = n; b = m; }
};
class Derived : protected Base {
int c;
public :
void setc(int n) { c = n; }
void showabc() {
cout << a <<' '<< b <<' '<< c << endl;
}
};
int main() {
Derived ob;
ob.setab(1, 2);
ob.setc(3);
ob.showabc();
return 0;
}
protected 상속으로 setab 이 Derived 에서 보호 멤버가 되어, 클래스 외부인 main 에서 호출할 수 없기 때문이다.
protected 상속은 기초 클래스의 public·protected 멤버를 모두 protected 로 바꾼다. 따라서 ob.setab(1, 2) 가 접근 오류다.
- 생성자를 정의하지 않으면 컴파일러가 기본 생성자를 만들어 주므로 객체 생성은 문제없다.
- a, b 는 Derived 에서 private 이 아니라 protected 이며, 멤버 함수 showabc 에서는 접근할 수 있다.
- C++ 은 public·protected·private 상속을 모두 허용한다.
2. E → E * T
3. E → T
4. T → ( E )
5. T → a
좌파스는 2 3 5 4 1 3 5 5, 우파스는 5 3 5 3 5 1 4 2이다.
좌파스는 좌단 유도에 쓴 규칙의 순서다. E ⇒ E*T(2) ⇒ T*T(3) ⇒ a*T(5) ⇒ a*(E)(4) ⇒ a*(E+T)(1) ⇒ a*(T+T)(3) ⇒ a*(a+T)(5) ⇒ a*(a+a)(5)
우파스는 우단 유도 규칙 순서의 역순이다. E ⇒ E*T(2) ⇒ E*(E)(4) ⇒ E*(E+T)(1) ⇒ E*(E+a)(5) ⇒ E*(T+a)(3) ⇒ E*(a+a)(5) ⇒ T*(a+a)(3) ⇒ a*(a+a)(5) 이므로 이를 뒤집어 5 3 5 3 5 1 4 2 가 된다.
- 우파스를 2 4 1 5 3 5 3 5 로 적은 조합은 우단 유도 순서를 뒤집지 않은 것이다.
- 좌파스를 2 4 1 5 3 5 3 5 로 적은 조합은 좌단이 아닌 우단 유도 순서를 쓴 것이다.
- 좌파스를 5 3 5 3 5 1 4 2 로 적은 조합은 우파스를 좌파스 자리에 둔 것이다.
new Runnable() {…} 은 Runnable 구현 객체를 만들 뿐 Thread 객체가 아니므로 옳지 않다.
Thread 객체를 만들려면 Thread 를 생성하거나 상속하거나, Runnable 객체를 Thread 생성자에 넘겨야 한다.
- new Thread(); 는 Thread 객체를 직접 생성한다(run 은 비어 있다).
- Thread 를 상속한 익명 클래스로 run 을 재정의해 생성하는 방법이다.
- Runnable 익명 객체를 Thread 생성자에 전달해 생성하는 방법이다.
public class FourTimes {
private static int j = 0;
public static boolean methodB(int k) {
j += k;
return true;
}
public static void methodA(int i) {
boolean b;
b = (i<10 | methodB(4)) &&
(i<10 || methodB(4));
}
static void methodC() {
try {
methodD();
methodB(4);
} catch (ArithmeticException e) {
methodB(4);
} catch (NullPointerException e) {
methodB(4);
} catch (Exception e) {
methodB(4);
} finally {
methodB(4);
}
}
static void methodD() {
throw new NullPointerException();
}
public static void main(String[ ] args) {
methodA(0);
try {
methodC();
} catch (Exception e) {
methodA(10);
}
System.out.println(j);
}
}출력은 12이다. | 는 단락 평가를 하지 않고 || 는 단락 평가를 하며, finally 는 항상 실행된다.
methodA(0): i<10 | methodB(4) 에서 | 는 양쪽을 모두 평가해 j 가 4 가 된다. 뒤의 i<10 || methodB(4) 는 앞이 true 라 methodB 를 호출하지 않는다.
methodC: methodD 가 NullPointerException 을 던져 다음 줄은 건너뛰고, 해당 catch 에서 j 가 8, finally 에서 12 가 된다. 예외가 처리되었으므로 main 의 catch 와 methodA(10) 은 실행되지 않는다.
- 8 은 finally 실행을 빠뜨린 값이다.
- 16 은 || 에서도 methodB 가 호출된다고 본 값이다.
- 20 은 main 의 catch 가 실행되어 methodA(10) 에서 8 이 더 더해진다고 본 값이다.
import java.util.*;
class Guest {
private String _name;
public Guest(String name) { _name = name; }
public String getName() { return _name; }
}
class GuestList extends Vector<Guest> {
public GuestList() { super(); }
public Guest getAt(int index) {
return super.get(index);
}
public void addTail(Guest ptr) { super.add(ptr); }
public void removeGuest(String name) {
Guest tmp;
for (int i = 0; i< this.elementCount; i++) {
tmp = this.elementAt(i);
if (name.equals(tmp.getName()))
super.removeElementAt(i);
}
}
}
public class GuestMan {
public static void main(String[ ] args) {
GuestList guests = new GuestList();
guests.addTail(new Guest("Jennifer"));
guests.addTail(new Guest("Susan"));
guests.addTail(new Guest("Mary"));
guests.removeGuest("Jennifer");
Iterator<Guest> i = guests.iterator();
while (i.hasNext())
System.out.print(i.next().getName() + " ");
}
}
GuestList 는 Vector<Guest> 로 타입 인자가 고정된 클래스라 Guest 만 담으므로, 매개변수적 다형 리스트로 쓸 수 있다는 설명이 틀렸다.
매개변수적 다형성은 GuestList<T> 처럼 타입 매개변수를 열어 두어 임의 타입에 같은 코드를 쓰는 것인데, 이 클래스는 그렇지 않다.
- Jennifer 는 첫 원소라 제거되고 나머지가 앞으로 당겨져 Susan Mary 가 출력되므로 옳다.
- 범용 Vector 를 상속해 손님 목록이라는 특수 용도의 클래스를 정의했으므로 옳다.
- Vector 는 원소가 늘면 용량이 자동으로 커지므로 저장 개수가 미리 정해져 있지 않다.
액션테이블의 기억 공간 축소는 테이블 압축 기법일 뿐 충돌 해결 방법이 아니므로 옳지 않다.
모호한 문법의 LR 충돌은 우선순위·결합법칙 같은 규칙을 정해 충돌한 테이블 항목 중 하나를 고르는 방식으로 해결한다.
- 이동-축약 충돌에서 이동을 우선하면 dangling else 를 가장 가까운 if 에 묶는 식으로 해결된다.
- 연산자 우선순위를 비교해 높은 쪽이 먼저 처리되도록 이동 또는 축약을 고른다.
- 우선순위가 같으면 좌결합은 축약, 우결합은 이동을 골라 해결한다.