결과 값이 가장 큰 식은 7-5*2로, 값은 4이다.
-가 *보다 먼저 묶이므로 각 식을 - 부분부터 계산하고, 연속된 -는 오른쪽부터 묶는다. 따라서 7-5*2는 (7-5)*2 = 4가 된다.
- 1-3-2*2는 (1-(3-2))*2 = 0*2 = 0이다.
- 4-1*1-2는 (4-1)*(1-2) = 3*(-1) = -3이다.
- 2*4-5는 2*(4-5) = -2이다.
interface B {
int b=1;
int f();
}
abstract class A implements B {
public abstract void g(int i);
public int f() { return b*2; }
}
class C extends A {
public void g(int i) { System.out.println(i*2); }
public int f() { return super.f()*2; }
}
class D extends C {
public void g(int i) { System.out.println(i*3); }
}
public class Test {
public static void main(String[] args) {
C c = new D();
c.g(c.f());
}
}실행 결과는 12이다.
c.f()는 D가 C에서 물려받은 f()가 실행되어 super.f()*2가 된다. A의 f()가 b*2 = 2를 돌려주므로 c.f()는 4이다.
이어 c.g(4)는 참조 변수 타입이 C여도 실제 객체가 D이므로 동적 바인딩에 의해 D의 g()가 호출되어 4*3 = 12를 출력한다.
- 결과를 1로 보는 것은 인터페이스 상수 b 값을 그대로 쓴 것으로, f()와 g()의 곱셈을 반영하지 않았다.
- 결과를 2로 보는 것은 A의 f()만 적용한 값으로, C의 f()가 super.f()에 다시 2를 곱하는 것을 빠뜨렸다.
- 결과를 8로 보는 것은 C의 g()(i*2)가 호출된다고 본 것으로, 실제로는 D가 g()를 재정의했으므로 i*3이 적용된다.
#include <stdio.h>
void fun(int a, int b, int c)
{
if(c!=0) {
fun(b, a+b, c-1);
printf("%d %d %d\n",a,b,c);
}
}
int main(int argc, char* argv[])
{
int i=1, j=1, k=3;
fun(i,j,k);
return 0;
}
2 3 1
1 2 2
1 2 2
1 1 3
1 2 1
1 1 2
1 2 2
2 3 1
실행 결과는 2 3 1 / 1 2 2 / 1 1 3 순서의 세 줄이다.
printf가 재귀 호출 뒤에 있으므로 가장 깊은 호출부터 거꾸로 출력된다. 호출은 fun(1,1,3) → fun(1,2,2) → fun(2,3,1) → fun(3,5,0)이며, c가 0인 마지막 호출은 아무것도 출력하지 않는다.
- ‘3 5 0’으로 시작하는 결과는 c가 0인 호출도 출력한다고 본 것이지만, if(c!=0) 조건 때문에 출력되지 않는다.
- ‘2 3 0 / 1 2 1 / 1 1 2’는 c를 1씩 줄여 잘못 적은 것으로, 각 호출은 자기 매개변수 c를 그대로 출력한다.
- ‘1 1 3 / 1 2 2 / 2 3 1’은 출력문이 재귀 호출 앞에 있을 때의 순서로, 이 코드는 호출이 끝난 뒤 출력하므로 역순이 된다.
#include<iostream.h>
class Polygon {
public: virtual void edges() { cout<< "NA "; } // ㉠
};
class Rectangle : public Polygon {
public: void edges() { cout<< "4 "; }
};
class Triangle : public Polygon {
public: void edges() { cout<< "3 "; }
};
class Varangle : public Polygon {
public: void edges(int e) { cout<< "# "; }
};
int main(int argc, char* argv[])
{
Polygon* p[3];
p[0] = new Rectangle();
p[1] = new Triangle();
p[2] = new Varangle();
for (int i = 0; i< 3; i++)
p[i]->edges();
return 0;
}
옳은 설명은 ㉠에서 virtual을 제거하면 “NA NA NA ”가 출력된다는 것이다.
virtual을 빼면 p[i]->edges()가 포인터의 선언 타입인 Polygon 기준으로 정적 바인딩되어 세 객체 모두 Polygon의 edges()를 호출한다.
virtual이 있으면 동적 바인딩으로 Rectangle은 “4 ”, Triangle은 “3 ”을 출력하고, Varangle의 edges(int)는 매개변수가 달라 재정의가 아니므로 Polygon의 edges()가 실행되어 “NA ”가 출력된다.
- 원래 프로그램이 “NA NA NA ”를 출력한다는 설명은 virtual에 의한 동적 바인딩을 무시한 것으로, 실제 출력은 “4 3 NA ”이다.
- 원래 프로그램이 “4 3 # ”를 출력한다는 설명은 틀리다. edges(int)는 인자 없는 edges()를 오버라이딩하지 않으므로 Varangle 객체에서는 “NA ”가 나온다.
- virtual을 제거하면 “4 3 NA ”가 출력된다는 설명은 virtual이 있을 때의 결과를 제거한 경우로 잘못 적은 것이다.
#include <stdio.h>
int y = 3;
int sample()
{
++y;
return(5);
}
int main(int argc, char* argv[])
{
int x;
x = sample() * 2;
x = x + y;
printf("%d \n", x);
return 0;
}
실행 결과는 14이다.
y는 전역 변수이므로 sample() 안의 ++y가 전역 y를 3에서 4로 바꾼다. x = sample()*2 = 10이고, x = x + y = 10 + 4 = 14가 된다.
- 결과를 13으로 보는 것은 sample()이 전역 y를 바꾸지 않는다고 보아 10 + 3으로 계산한 것이다.
- 결과를 15로 보는 것은 y가 두 번 증가했다고 본 것이지만 sample()은 한 번만 호출된다.
- 오류 메시지가 출력된다는 것은 틀리다. 함수 안에서 전역 변수를 수정하는 것은 정상적인 C 코드이다.
제네릭(템플릿) 기능을 지원하지 않는 언어는 Pascal이다.
표준 Pascal에는 자료형을 매개변수로 받는 일반화 기능이 없어 자료형마다 같은 루틴을 따로 작성해야 한다. 반면 나머지 언어는 타입 매개변수를 쓰는 제네릭 단위를 제공한다.
- C++은 template 키워드로 함수 템플릿과 클래스 템플릿을 지원한다.
- Java는 JDK 5부터 List<String> 같은 제네릭을 지원한다.
- Ada는 generic 패키지와 부프로그램을 언어 차원에서 일찍부터 지원했다.
public class ex1 {
public static void main(String args[]) {
int i, a = 0;
int b[] = new int[3];
for(i=0; i<=2; i++) {
System.out.println("i=" + i);
try {
if (i == 0) a = 10/0;
if (i == 1 ) a = 1;
if (i == 2) a = b[i+3];
}
catch (ArithmeticException e) {
System.out.println("error - divide by zero");
}
catch (ArrayIndexOutOfBoundsException e) {
System.out.println("error - out of bound");
}
finally {
i++;
}
}
System.out.println("a=" + a);
}
}error - divide by zero
i=2
error - out of bound
a=1
a=1
error - divide by zero
i=2
error - out of bound
a=0
error - divide by zero
i=1
i=2
error - out of bound
a=0
실행 결과는 i=0, error - divide by zero, i=2, error - out of bound, a=0의 다섯 줄이다.
finally 블록은 예외 발생 여부와 관계없이 항상 실행되므로, i가 finally에서 한 번, for문 증감식에서 한 번 더 증가해 i=0과 i=2일 때만 반복한다.
i=0에서는 10/0으로 ArithmeticException이, i=2에서는 b[5] 접근으로 ArrayIndexOutOfBoundsException이 발생한다. 두 경우 모두 대입이 이루어지지 않으므로 a는 초기값 0을 유지한다.
- 마지막 줄이 a=1인 다섯 줄 결과는 a=1 대입이 실행된다고 본 것이지만, finally의 i++ 때문에 i=1 반복은 건너뛴다.
- i=0과 a=1 두 줄만 나오는 결과는 예외 처리기의 출력과 이후 반복을 모두 무시한 것이다.
- i=1이 출력되는 결과는 finally의 i++를 반영하지 않은 것이다.
#include <stdio.h>
void printtest(int *p, int size);
int main(int argc, char* argv[])
{
int a[5] = {10, 20, 30, 40, 50};
int size = sizeof(a)/sizeof(a[0]);
printtest(a, size/2);
return 0;
}
void printtest(int *p, int size)
{
printf("%d \n", p[size]);
}
실행 결과는 30이다.
sizeof(a)/sizeof(a[0])는 배열 원소 개수 5이고, 정수 나눗셈 size/2는 2가 된다. 배열 이름 a는 첫 원소의 주소로 전달되므로 p[2]는 a[2]와 같다.
- 결과를 20으로 보는 것은 a[1]의 값으로, 인덱스가 0부터 시작함을 고려하지 않은 것이다.
- 결과를 40으로 보는 것은 a[3]의 값으로, 5/2를 반올림해 3으로 본 것이다.
- 결과를 50으로 보는 것은 a[4]의 값으로, size/2 위치가 아닌 마지막 원소를 출력한다고 본 것이다.
#include <stdio.h>
int main(int argc, char* argv[])
{
int *a;
int b[5] = {2, 4, 7};
a = &b[0];
printf("%d, %d, %d \n", *a+3, *(a+3), a+3);
return 0;
}
실행 결과는 5, 0, 7106이다.
*a+3은 단항 *가 먼저 적용되어 b[0]에 3을 더한 2 + 3 = 5이다. *(a+3)은 b[3]인데, 배열을 일부만 초기화하면 나머지 원소는 0으로 초기화되므로 0이다.
a+3은 포인터 연산이므로 int 크기(32bit 환경에서 4바이트)의 3배만큼 주소가 증가한다.
- ‘5, 7, 7100’은 *(a+3)을 b[2]로 착각하고 int를 2바이트로 보아 주소를 6만 증가시킨 것이다.
- ‘0, 7, 7106’은 앞의 두 값을 잘못 본 것이다. *a+3은 단항 *가 +보다 먼저 적용되어 5이고, *(a+3)은 b[3]이므로 0이다.
- ‘5, 0, 7100’은 값은 맞지만 int를 2바이트로 보아 주소를 6만 증가시킨 것이다.
옳지 않은 설명은 파생 클래스에서 기저 클래스에 없는 메소드를 새로 정의할 수 없다는 것이다.
상속은 기저 클래스의 멤버를 물려받으면서 파생 클래스가 새 멤버를 추가하거나 기존 메소드를 재정의해 기능을 확장하는 기법이다.
- 함수 오버로딩은 이름이 같고 매개변수의 자료형이나 개수가 다를 때 성립하므로 옳다.
- 캡슐화는 관련된 상수·타입·변수·메소드를 하나의 단위로 묶는 기법이므로 옳다.
- 상속의 대표적 장점이 코드 재사용성이라는 설명은 옳다.
#include <stdio.h>
int main(int argc, char* argv[])
{
char string[2][10] = {"variable", "constant"};
printf("%s, %c \n", string, *(string[0]+1));
return 0;
}
실행 결과는 variable, a이다.
%s에 전달된 string은 첫 행 string[0]의 시작 주소로 변환되므로 “variable”이 출력된다. *(string[0]+1)은 첫 행의 두 번째 문자인 a이다.
- ‘variable, v’는 +1을 무시하고 첫 문자를 꺼낸 것이다.
- ‘constant, c’는 string이 두 번째 행을 가리킨다고 본 것이지만, 배열 이름은 첫 행의 주소이다.
- ‘variable, o’의 o는 두 번째 행 “constant”의 두 번째 문자로, string[0]이 아닌 string[1]을 참조한 경우이다.
class IfElse {
public static void main(String args[]) {
long charge = 5000 ;
String country = args[0];
String city = args[1];
if (country.equals("한국"))
if(city.equals("제주도"))
charge = 10000;
else
charge = 20000;
System.out.println(charge);
}
}옳은 설명은 “java IfElse 한국 부산”을 실행하면 20000이 출력된다는 것이다.
들여쓰기와 무관하게 else는 가장 가까운 if, 즉 city를 검사하는 안쪽 if와 짝이 된다(dangling else). 따라서 country가 “한국”일 때만 안쪽 if가 실행되어 제주도면 10000, 그 밖의 도시면 20000이 되고, 한국이 아니면 초기값 5000이 유지된다.
- 해외 국가 이름이면 20000이 출력된다는 설명은 틀리다. 바깥 if가 거짓이면 else도 실행되지 않아 5000이 출력된다.
- 한국이면서 제주도가 아닌 도시일 때 5000이 된다는 설명은 틀리다. 안쪽 if의 else가 실행되어 20000이 된다.
- “중국 상해”로 실행하면 20000이 출력된다는 설명은 틀리다. country가 한국이 아니므로 5000이 출력된다.
옳지 않은 설명은 main() 함수의 괄호 안에 인자가 올 수 없다는 것이다.
프로그램이 main()부터 실행된다는 앞부분은 맞지만, main()은 int main(int argc, char* argv[])처럼 명령행 인자를 매개변수로 받을 수 있다.
- #define, #include는 컴파일 전에 처리되는 전처리기 지시자이므로 옳다.
- 함수 본체의 시작과 끝은 중괄호 { }로 표시하므로 옳다.
- int, char 같은 기본 자료형 이름은 예약어이므로 변수 이름으로 쓸 수 없다는 설명은 옳다.
#include <iostream.h>
void ErrorHandler(int test)
{
try {
if (test) throw test;
else throw "예외 발생";
}
catch(int i) {
cout << "예외에서 잡은 숫자 : " << i << "\n";
}
catch(char *str) {
cout << "예외에서 잡은 문자열 : " << str << "\n";
throw;
}
}
int main(int argc, char* argv[])
{
try {
ErrorHandler(1);
ErrorHandler(0);
ErrorHandler(2);
}
catch(char *) {
cout << "메인함수에서 잡은 예외 \n";
}
return 0;
}
예외에서 잡은 숫자 : 0
예외에서 잡은 숫자 : 2
예외에서 잡은 문자열 : 예외 발생
예외에서 잡은 숫자 : 2
예외에서 잡은 문자열 : 예외 발생
메인함수에서 잡은 예외
예외에서 잡은 문자열 : 예외 발생
메인함수에서 잡은 예외
예외에서 잡은 숫자 : 2
실행 결과는 숫자 1, 문자열 “예외 발생”, “메인함수에서 잡은 예외”가 차례로 출력되는 세 줄이다.
ErrorHandler(1)은 정수 1을 던져 catch(int)에서 처리된다. ErrorHandler(0)은 문자열을 던져 catch(char *)에서 출력한 뒤, 피연산자 없는 throw;로 예외를 다시 던진다.
다시 던진 예외는 main의 catch(char *)가 받으므로, try 블록의 나머지인 ErrorHandler(2)는 실행되지 않는다.
- 숫자 0이 잡힌다는 결과는 틀리다. test가 0이면 if 조건이 거짓이어서 정수가 아닌 문자열을 던진다.
- 마지막 줄이 ‘예외에서 잡은 숫자 : 2’인 결과는 재던지기로 main의 try 블록을 빠져나간다는 점을 무시한 것이다.
- 메인 함수의 출력 뒤에 ‘예외에서 잡은 숫자 : 2’가 이어지는 결과는 틀리다. 예외가 catch로 넘어가면 try 블록의 남은 문장으로 돌아가지 않는다.
생성되는 언어의 정규표현은 (a|b)*a이다.
<E>는 앞에 a 또는 b를 하나씩 붙이며 재귀하다가 마지막에 반드시 a로 끝난다. 따라서 a, b로 이루어진 임의의 문자열 뒤에 a가 붙은, 즉 a로 끝나는 문자열의 집합이다.
- (ab)*a는 ab가 반복되는 형태만 허용해 aa, baa 같은 문자열을 만들 수 없다.
- a*|b*|a는 b만으로 된 문자열이나 빈 문자열처럼 a로 끝나지 않는 문자열을 포함한다.
- a*b*a는 a가 b보다 앞에만 올 수 있어 baba, abaa 같은 문자열을 만들 수 없다.
class Super {
int index = 1;
public void printVal() {
System.out.println("super");
}
}
class Sub extends Super {
int index = 2;
public void printVal() {
System.out.println("sub");
}
}
public class Test2 {
public static void main(String args[]) {
Super sup1 = new Sub();
System.out.println(sup1.index);
sup1.printVal();
}
}super
sub
super
sub
실행 결과는 1, sub의 두 줄이다.
Java에서 필드는 오버라이딩되지 않고 참조 변수의 선언 타입으로 결정되므로, Super 타입인 sup1.index는 Super의 index인 1이다.
반면 메소드는 실제 객체 타입으로 결정되는 동적 바인딩이 적용되어 Sub의 printVal()이 “sub”를 출력한다.
- ‘1, super’는 메소드도 선언 타입으로 결정된다고 본 것이다.
- ‘2, super’는 필드와 메소드의 결정 방식을 서로 뒤바꾼 것이다.
- ‘2, sub’는 필드도 실제 객체 타입을 따른다고 본 것으로, Sub의 index는 Super의 index를 가릴(hiding) 뿐 재정의하지 않는다.
#include <stdio.h>
int main(int argc, char* argv[])
{
int a= 1, b, c, d;
d = (b= a++, c = b+2);
printf("a=%d, b=%d, c=%d, d=%d\n", a, b, c, d);
return 0;
}
실행 결과는 a=2, b=1, c=3, d=3이다.
콤마 연산자는 왼쪽부터 차례로 평가하고 마지막 피연산자의 값을 결과로 한다. b = a++는 후위 증가이므로 b에 1이 대입된 뒤 a가 2가 된다.
이어 c = b + 2 = 3이고, 콤마 식 전체의 값인 3이 d에 대입된다.
- ‘a=2, b=1, c=4, d=4’는 b가 1이면 c는 b + 2 = 3이어야 하므로 성립할 수 없다.
- ‘a=2, b=2, c=3, d=3’은 a++를 전위 증가로 보아 b를 2로 둔 데다, c도 b + 2로 계산하지 않았다.
- ‘a=2, b=2, c=4, d=4’는 a++를 전위 증가(++a)처럼 처리한 결과이다.
참조에 의한 전달은 호출 함수가 실 매개변수의 주소를 피호출 함수에 넘기는 기법이다.
형식 매개변수가 실 매개변수와 같은 기억 장소를 가리키므로, 피호출 함수에서 값을 바꾸면 호출 측 변수도 함께 바뀐다.
- 실제 값을 형식 매개변수에 복사해 전달하는 것은 값에 의한 전달(call by value)이다.
- 실 매개변수를 결과를 받는 용도로만 쓰는 것은 결과에 의한 전달(call by result)이다.
- 형식 매개변수가 쓰일 때마다 실 매개변수를 다시 계산하는 것은 이름에 의한 전달(call by name)이다.
public class ClassA {
int tmp = 100;
ClassA() {
System.out.println("tmp = " + tmp);
tmp = 200;
}
public static void main(String[] args) {
ClassA inst = new ClassA();
System.out.println("tmp = " + inst.tmp);
}
}tmp = 200
tmp = 100
실행 결과는 tmp = 100, tmp = 200의 두 줄이다.
객체 생성 시 필드 초기화 int tmp = 100이 생성자 본체보다 먼저 실행되므로 생성자 안의 첫 출력은 100이다. 그 뒤 생성자가 tmp를 200으로 바꾸고, main에서 inst.tmp를 출력하면 200이 나온다.
- ‘tmp = 100’ 한 줄만 나온다는 결과는 생성자의 출력만 반영하고 main의 출력을 빠뜨린 것이다.
- ‘tmp = 200’ 한 줄만 나온다는 결과는 생성자 안의 출력문을 빠뜨린 것이다.
- ‘tmp = 200’ 뒤에 ‘tmp = 100’이 나온다는 결과는 출력 순서와 값의 변경 시점을 거꾸로 본 것이다.
#include <stdio.h>
int main(int argc, char* argv[])
{
int x = 3; int y = 4; int z = 5 ;
x = y;
{
int x = 7, y = 2;
x = z;
printf("x1=%d, y1=%d, z1=%d \n", x, y, z);
}
printf("x2=%d, y2=%d, z2=%d \n", x, y, z);
return 0;
}
x2=4, y2=4, z2=5
x2=5, y2=4, z2=5
x2=4, y2=5, z2=5
x2=4, y2=4, z2=4
실행 결과는 x1=5, y1=2, z1=5와 x2=4, y2=4, z2=5이다.
블록 안에서 선언한 x, y는 바깥 변수를 가리는 지역 변수이므로 x = z는 안쪽 x만 5로 바꾼다. z는 블록 안에서 새로 선언되지 않았으므로 바깥 z(5)를 그대로 참조한다.
블록이 끝나면 안쪽 변수는 사라지고, 바깥 x는 앞서 x = y로 대입된 4, y는 4, z는 5이다.
- ‘z1=4, x2=5’가 포함된 결과는 블록 안의 대입이 바깥 x에 적용된다고 본 것이다.
- ‘x1=4, y1=5’로 시작하는 결과는 안쪽 x가 z 값을 받는다는 점과 y의 값을 잘못 본 것이다.
- ‘y1=5’와 ‘z2=4’가 포함된 결과는 안쪽 y가 2로 선언되고 z는 바뀌지 않는다는 점을 무시한 것이다.