[2021년 3회]

< C++ >

# 1. 다음 C언어에 대한 알맞은 출력값을 쓰시오.

[소스코드]

#include <stdio.h>

int main() 
{
	int* arr[3];
	int a = 12, b = 24, c = 36;
	arr[0] = &a;
	arr[1] = &b;
	arr[2] = &c;
	printf("%d\n", *arr[1] + **arr + 1);
}

크기가 3인 포인터 배열 arr 선언

정수 a = 12, b = 24, c = 36으로 초기화

arr[0] = &a // arr[0]은 a의 주소를 나타냄

arr[1] = &b // arr[1]은 b의 주소를 나타냄

arr[2] = &c // arr[2]은 c의 주소를 나타냄

	arr[0]	arr[1]	arr[2]
arr	&a	&b	&c

*arr[1] = 24

**arr + 1 → *arr[0] + 1 → 12 + 1 = 13

 

[출력결과]

37

 

# 2. 다음 C언어에 대한 알맞는 출력값을 쓰시오.

[소스코드]

#include <stdio.h>

struct jsu 
{
    char name[12];
    int os, db, hab, hhab;
};

int main() 
{
    struct jsu st[3] = {{"데이터1", 95, 88}, {"데이터2", 84, 91}, {"데이터3", 86, 75}};
    struct jsu* p;

    p = &st[0];

    (p + 1) -> hab = (p + 1) -> os + (p + 2) -> db;
    (p + 1) -> hhab = (p + 1) -> hab + p->os + p -> db;

    printf("%d\n", (p + 1) -> hab + (p + 1) -> hhab);
}

구조체 jsu 정의

크기가 3인 배열 st 구조체에 name, os, db에 각각 "데이터1", 95, 88 / "데이터2", 84, 91 / "데이터3", 86, 75으로 초기화

hab, hhab 은 0으로 초기화

구조체 포인터 p를 선언

p = &st[0]; // 구조체 포인터 p는 구조체 배열 st[0]의 주소를 가지고 있음

 

(p + 1) -> hab = (p + 1) -> os + (p + 2) -> db;

(p + 1) -> os는 구조체 배열 st[1]주소의 os의 값을 가리키고 있음 // 84

(p + 2) -> db는 구조체 배열 st[2]주소의 db의 값을 가리키고 있음 // 75

(p + 1) -> hab = 159 // 구조체 배열 st[1]주소의 hab 값에 159 대입

(p + 1) -> hhab = (p + 1) -> hab + p -> os + p -> db;

p -> os는 구조체 배열 st[0]주소의 os의 값을 가리키고 있음 // 95

p -> db는 구조체 배열 st[0]주소의 db의 값을 가리키고 있음 //88

(p + 1) -> hhab = 159 + 95 + 88 = 342 // 구조체 배열 st[1]주소의 hhab 값에 342 대입

 

[출력결과]

501

 

---

 

< Java >

# 1. 다음 Java 코드에 대한 알맞은 출력값을 쓰시오.

class Connection 
{
    private static Connection _inst = null;
    private int count = 0;
    static public Connection get() 
    {
        if(_inst == null) 
        {
            _inst = new Connection();
            return _inst;
        }
        return _inst;
    }
    public void count() 
    {
        count++;
    }
    public int getCount() 
    {
        return count;
    }
}

public class testcon 
{
    public static void main(String[] args) 
    {
        Connection conn1 = Connection.get();
        conn1.count();
        Connection conn2 = Connection.get();
        conn2.count();
        Connection conn3 = Connection.get();
        conn3.count();

        System.out.print(conn1.getCount());
    }
}

Connection conn1 = Connection.get();

Connection 타입 conn1은 Connection.get() 메서드로 if(_inst == null) 인스턴스가 null이면 _inst를 Connection클래스의 생성자를 호출해 새로운 객체를 생성하여 _inst를 리턴

Connection 타입 conn2은 Connection.get() 메서드로 if(_inst == null) 인스턴스가 null이면 _inst를 Connection클래스의 생성자를 호출해 새로운 객체를 생성하여 _inst를 리턴

Connection 타입 conn3은 Connection.get() 메서드로 if(_inst == null) 인스턴스가 null이면 _inst를 Connection클래스의 생성자를 호출해 새로운 객체를 생성하여 _inst를 리턴

 

사실상 conn, conn2, conn3 모두 동일한 인스턴스를 갖게 된다

Connection 클래스의 초기 인스턴스는 null로 정의되어 있는데,  get() 메서드를 보면 인스가 null이면 새 인스턴스를 생성하고 인스턴스를 리턴해주는데 이때 Connection클래스의 인스턴스는 null이 아닌 어떠한 객체로 정의가 된다

그래서 이후에 Connection conn2 = Connection.get()을 호출하면 이미 conn1에서 객체를 생성해서 Connection 클래스의 인스턴스는 null이 아니기 때문에 conn2에서 get()을 호출할 때 if문에서 false를 반환하기 때문에 그대로 conn1의 인스턴스를 리턴해준다

결국은 conn1.count()를 3회 반복하는 것이 다름없기 때문에 count = 3

위 사진은 conn1, conn2, conn3 인스턴스가 동일하다는 것을 디버깅을 통해 보여준다

 

[출력결과]

3

 

# 2. 다음 Java 코드에 대한 알맞은 출력값을 쓰시오.

[소스코드]

public class good 
{
    public static void main(String[] args) 
    {
        int a = 3, b = 4, c = 3, d = 5;
        if ((a == 2 | a == c) & !(c > d) & (1 == b ^ c != d)) 
        {
            a = b + c;
            
            if (7 == b ^ c != a) 
            {
                System.out.println(a);
            } 
            else 
            {
                System.out.println(b);
            }
        } 
        else 
        {
            a = c + d;
            if (7 == c ^ d != a) 
            {
                System.out.println(a);
            } 
            else 
            {
                System.out.println(d);
            }
        }
    }
}

정수 a = 3, b = 4, c= 3, d = 5로 초기화

if ((a == 2 | a == c) &!(c > d) & (1 == b ^ c != d))

a ==2  → F, a == c → T(1)

(a == 2 | a ==c) → T(1)

c > d → F(0)

!(c > d) → T(1)

1 == b → F(0)

c != d → T(1)

(1 == b ^ c != d) → 0 ^ 1 XOR 연산 → T(1)

((a == 2 | a == c) & !(c > d) & (1 == b ^ c != d)) → (1 & 1 & 1) →  T(1)

a = b + c → a = 7로 초기화

if (7 == b ^ c != a)

7 == b → F

c != a →  T

(7 == b ^ c != a) → 0 ^ 1 XOR 연산 → T(1)

 

[출력결과]

7

 

---

 

< Python >

# 1. 다음 파이썬 코드이다. 알맞은 출력값을 쓰시오.

a, b = 100, 200 
print(a == b)

C++에서 정수를 비교할 때는 true, false

Java에서 정수를 비교할 때 는 true, false

파이썬에서 정수를 비교할 때 는 True, False

 

[출력결과]

False