1. 프로그래밍 언어 활용 : 프로그래밍 언어 활용

강재훈·2026년 2월 6일

실기 정보처리기사

정보처리기사 실기

목록 보기

2/9

📍 Chapter 2 : 프로그래밍 언어 활용

🍀 Section 1 | 프로그래밍 언어 활용

1. 프로그래밍 언어 활용의 개요

💡 프로그래밍 언어

컴퓨터 시스템을 동작시키기 위한 프로그램 작성 언어

프로그램은 다소 단순해 보이는 명령어들의 조합들로 구성된다.
명령어들의 조합들은 비트(Bit)라고 불리는 0과 1의 값으로 작성되거나 변환되어 컴퓨터가 이해할 수 있게 한다.

1) 비트(Bit)

컴퓨터가 이해할 수 있는 가장 기본적인 용어로, Binary Digit의 약칭이다.
0과 1로만 구성된 이진법을 이용한다.

단위	값
바이트	1 Byte(B) = 8 bit
킬로바이트	1 Kilobyte(KB) = 8,192 bit
메가바이트	1 Megabyte(MB) = 8,388,608 bit
기가바이트	1 Gigabyte(GB) = 8.5899e+9 bit
테라바이트	1 Terabyte(TB) = 8.7961e+12 bit
페타바이트	1 Petabyte(PB) = 9.0072e+15 bit
엑사바이트	1 Exabyte(EB) = 9.2234e+18 bit

2) 컴퓨터 시스템의 구조

컴퓨터는 전달받은 0과 1의 값들을 정해진 순서대로 실행하며 그 과정에서 처리(Processing), 저장(Store) 등을 수행한다.

시스템	하는 일
중앙처리장치(CPU)	프로그램 실행 및 데이터 처리
기억장치(Memory)	저장
입출력장치(I/O Device)	중앙처리장치로부터 명령을 받아 데이터를 입력 또는 출력

💡 컴퓨터 구조(CPU 파이프라인)에서 명령어를 처리하는 5단계

단계	설명
IF, Instruction Fetch	명령어 인출, 메모리에서 명령어를 가져오는 단계
ID, Instruction Decode	명령어 해독, 명령어를 해석하고 레지스터 파일을 읽는 단계
EX, Excute	실행, 산술논리장치(ALU)를 이용한 연산 및 주소 계산 단계
MEM, Memory	메모리 접근, 메모리에서 데이터를 읽거나 쓰는 단계
WB, Write Back	쓰기, 연산 결과를 레지스터에 기록하는 마지막 단계

2. 프로그래밍 언어의 기본 문법 및 용어

1) 프로그래밍 기본 용어

용어	설명
변수	어떤 값을 주기억장치에 기억하기 위해서 사용하는 공간
식별자	프로그램의 구성요소를 구별하기 위한 기준. 변수명이 식별자에 속한다.
할당	변수에 메모리 공간을 바인딩하는 작업
바인딩	변수와 변수에 관련된 속성을 연결하는 과정. 정적 바인딩과 동적 바인딩으로 구분된다.
정적(Static) 바인딩	프로그램 실행 시간 전에 속성을 연결하는 방식
동적(Dynamic) 바인딩	프로그램 실행 시간에 속성을 연결하는 방식
데이터 타입	변수가 가질 수 있는 속성값의 길이 및 성질
선언	변수에 이름, 데이터 타입 등의 속성을 부여하는 작업. 명시적 선언과 묵시적 선언으로 구분된다.
명시적 선언	선언문을 이용하며 변수 이름을 나열하고 속성을 부여하는 방식
묵시적 선언	별도의 선언문 없이 디폴트 규칙에 의해 속성을 부여하는 방식
영역	이름이 사용되는 범위. 정적 영역과 동적 영역으로 구분된다.
정적 영역	변수를 찾을 때 구조에 기반하는 방식
동적 영역	변수를 찾을 때 구조보다는 순서에 기반하는 방식
연산자	데이터 처리를 위해 연산을 표현하는 기호. `+`, `-` 등과 같은 연산자를 포함한다.
명령문	프로그램을 구성하는 문장. 지시 사항을 처리하는 단위

2) 변수와 데이터 타입

2-1) 변수

저장하고자 하는 어떠한 값이 있을 때, 그 값을 주기억장치에 기억하기 위한 공간을 의미

2-2) 변수 선언 규칙

영문 대문자/소문자(대소문자 구분), 숫자, 밑줄(_) 사용이 가능하다.
첫 번째 자리는 숫자로 시작할 수 없다.
변수 이름의 중간에는 공백을 사용할 수 없다.
이미 사용되고 있는 예약어(키워드)는 변수로 사용할 수 없다.

2-3) 데이터 타입

변수에 들어갈 값의 특성을 구분하여 그 특성에 맞게 저장할 수 있도록 하는 데이터 속성값의 길이 및 성질을 의미한다.

2-4) 데이터 타입 유형

프로그래밍 언어에 따라 데이터 타입의 유형을 구분하는 기준에 차이가 있다.
일반적으로 아래와 같은 유형으로 나눈다.

💡 불린(Boolean) 타입

참과 거짓을 의미하는 데이터 타입

True(참)과 False(거짓) 두 가지의 값을 가지고 있다.

💡 문자(Character) 타입

문자 하나를 저장할 때 사용한다.
char a = 'A';

💡 문자열(String) 타입

문자열을 저장할 때 사용한다.
string a = "Hello World";

💡 정수(Integer) 타입

정수값을 저장하고자 할 때 사용한다.

Java와 C/C++의 정수 타입은 다음의 표와 같다.

☕️ Java

타입	크기
byte	1 byte
short	2 byte
int	4 byte
long	8 byte

🌐 C/C++

타입	크기
short	2 byte
unsigned short	2 byte
int	2 byte(16-bit System), 4 byte(32-bit System)
unsigned int	2 byte(16-bit System), 4 byte(32-bit System)
long	4 byte
unsigned long	4 byte

💡 부동 소수점 타입

소수점을 포함하는 실수값을 저장하고자 할 때 사용한다.

💡 배열(Array) 타입

여러 데이터를 하나로 묶어서 자정하고자 할 때 사용한다.

C언어에서는 배열의 공간(크기)을 선언하고, Java에서는 비워둔다.
// C언어 정수형 배열 선언
Array [5] = {1, 2, 3, 4, 5};
// Java 정수형 배열 선언
Array [] = {1, 2, 3, 4, 5};

💡 예제 1
다음의 출력 결과를 작성하시오.
#include <stdio.h>
  main(void) {
  	int num = 4;
    char str = 'a';
    printf("%d", sizeof(num) + sizeof(str));
  }
풀이 방식

변수 num의 타입은 int 이고, int의 바이트 크기는 4

변수 str의 타입은 char 이고, char의 바이트 크기는 1

답은 5

💡 예제 2
다음의 출력 결과를 작성하시오.
#include <stdio.h>
  main(void) {
  	int num1[4] = {1, 2, 3};
    int num2[2] = {9, 9};
    printf("크기 = %d", sizeof(num1) + sizeof(num1));
  }
풀이 방식

변수 num1과 num2의 타입은 정수형 배열이다.

num1의 바이트 크기는 4(int) x 4 = 16 이다.

num2의 바이트 크기는 4(int) x 2 = 8 이다.

답은 24

2-5) 서식 지정자

변수 혹은 값을 출력문을 통해 출력하기 위해 사용한다.
데이터를 입출력할 때 형식을 맞추는 문자

형태	문자	설명
정수형	%d	부호 있는 10진수 정수
	%u	부호 없는 10진수 정수
	%o	부호 없는 8진수 정수
	%x	부호 없는 16진수 정수
실수형	%f	소수점 6번째까지의 실수
	%e	0.000000e+00, 실수 지수 표현
	%g	%f 와 %e 둘중에 짧은 길이로 표현되는 서식 지정자를 사용
문자형	%c	단일 문자 출력
	%s	문자열 출력

💡 예시 코드

#include <stdio.h>
main(void) {
  char a = "A";
  int num1 = 2000;
  float num2 = 1.23;
  printf("%c %d %d %f", a, a, num1, num2);
  // 출력 : c 65 2000 1.230000
  // 문자 A는 ASCII 코드로 65
  // A를 %d로 출력할 시 65 출력
  return 0;
}

3. 연산자

프로그램 실행을 위해 연산을 표현하는 기호
산술, 시프트, 관계, 논리, 비트, 증감, 복합 대입, 삼항이 있다.

1) 산술 연산자

종류	설명	우선순위
`+`	양쪽의 값을 더한다.	3
`-`	왼쪽 값에서 오른쪽 값을 뺀다.	3
`*`	양쪽의 값을 곱한다.	2
`/`	왼쪽 값에서 오른쪽 값을 나눈다.	2
`%`	왼쪽 값에서 오른쪽 값을 나눈 나머지를 계산한다.	2

우선순위 1등은 괄호() 이다.
수학과 동일한 연산자 우선순위를 따른다.

💡 예제

#include <stdio.h>
main(void) {
  int result1, retult2;
  result1 = 10 + 15 % 4 - 20 % 9;
  result2 = 10 * 15 % 4 - 20 % 9 + 5;
  printf("%d %d", result1, result2);
  return 0;
}

답 : 11 5

2) 시프트 연산자

10진수의 값을 2진수로 변환하여 비트의 위치를 이동시키는 연산자이다.

종류	설명
`<<`	우측 값만큼 비트의 위치를 좌측으로 이동
`>>`	우측 값만큼 비트의 위치를 우측으로 이동

💡 예제

#include <stdio.h>
main(void) {
  int num1, num2, result;
  num1 = 15;
  num2 = 4'
  result = num1 >> 3 << num2
  printf("%d", result);
  return 0;
}

풀이방식

15 : 0000 1111
15 >> 3 : 0000 0001
1 << 4 : 0001 0000
0001 0000 = 16
답 : 16

3) 관계 연산자

두 피연산자 사이의 크기를 비교하는 연산자이다.
True와 False를 구분한다.

> : 초과 ⇒ printf("%d", 10 > 3); // 결과 : 1(True)

< : 미만 ⇒ printf("%d", 10 < 3); // 결과 : 0(False)

>= : 이상 ⇒ printf("%d", 5 >= 5); // 결과 : 1(True)

<= : 이하 ⇒ printf("%d", 5 <= 5); // 결과 : 1(True)

== : 같다 ⇒ printf("%d", 5 == 5); // 결과 : 1(True)

!= : 다르다 ⇒ printf("%d", 5 != 5); // 결과 : 0(False)

💡 예제

#include <stdio.h>
main(void) {
  int num1 = 10;
  int num2 = 5;
  int num3 = 15;
  int num4 = 7;
  int result1, result2;
  result1 = num1 > num2;
  result2 = num3 < num4;
  printf("%d", result1 < result2);
  return 0;
}

풀이방식

result1 : 10 > 5 ⇒ 1(True)
result2 : 15 < 7 ⇒ 0(False)
result1 < result2 : 1 < 0 ⇒ 0(False)
답 : 0

4) 논리 연산자

두 피연산자 사이의 논리적인 관계를 정의하는 연산자이다.

&&(AND) : 두 가지의 논리값이 모두 참일 때 True, 하나라도 거짓일 때 False를 반환한다. 10 > 5 && 5 < 10 ⇒ 1(True)
||(OR) : 두 가지의 논리값이 하나라도 참일 때 True, 하나라도 참일 때 True를 반환한다. 10 > 5 || 5 > 10 ⇒ 1(True)

💡 예제
#include <stdio.h>
main(void) {
  int num1 = 7;
  int num2 = 22;
  int num3 = 4;
  int num4 = 9;
  printf("결과1 : %d\n", num1 < num2 && num3 > num4);
  printf("결과2 : %d\n", num1 > num2 || num3 < num4);
  return 0;
}
풀이방식

num1 < num2 : 7 < 22 ⇒ 1(True)

num3 > num4 : 4 > 9 ⇒ 0(False)

1(True) && 0(False) ⇒ 0(False)

num1 > num2 : 7 > 22 ⇒ 0(False)

num3 < num4 : 4 < 9 ⇒ 1(True)

0(False) || 1(True) ⇒ 1(True)

답

결과1 : 0

결과2 : 1

5) 비트 연산자

0과 1의 각 자리에 대한 연산을 수행한다. 0과 1의 결과값을 가진다.
보통 우리가 사용하는 단위를 10진수로 표현하고, 컴퓨터의 언어는 이진수로 표현한다.

💡 예시

1 ⇒ 0000 0001

2 ⇒ 0000 0010

16 ⇒ 0001 0000

27 ⇒ 0001 1011

182 ⇒ 1011 0110

&(AND) : 두 값을 비트로 연산하여 모두 참(True, 1)이면 참을 반환, 하나라도 거짓(False, 0)이면 거짓을 반환한다.
|(OR) : 두 값을 비트로 연산하여 하나라도 참(True, 1)이면 참을 반환, 모두 거짓(False, 0)이면 거짓을 반환한다.
^(XOR) : 두 값을 비트로 연산하여 서로 다르면 참을 반환, 같으면 거짓을 반환한다.

💡 예제
#include <stdio.h>
main(void) {
  int num1 = 37;
  int num2 = 13;
  int result1 = num1 & num2;
  int result2 = num1 | num2;
  printf("result1 : %d\n", result1);
  printf("result2 : %d", result2);
  return 0;
}
풀이방식

num1 & num2 : 0010 0101 & 0000 1101 ⇒ 0000 0101

num1 | num2 : 0010 0101 | 0000 1101 ⇒ 0010 1101

0000 0101 : 4 + 1 =5

0010 1101 : 32 + 8 + 4 + 1 =45

답

result1 :5

result2 :45

6) 증감 연산자

피연산자를 1씩 증가시키거나 감소시킬 때 사용하는 연산자이다.
부호의 위치에 따라 전위 연산자와 후위 연산자로 구분된다.

💡 전위 연산자

피연산자를 증감한 후, 해당 라인의 연산을 수행
int a = 5;
int b = 10;
printf("%d %d", ++a, --b) // 6 9
printf("%d %d", a, b) // 6 9

💡 후위 연산자

해당 라인의 연산을 수행한 후 피연산자를 증감
int a = 5;
int b = 10;
printf("%d %d", a++, b--) // 5 10
printf("%d %d", a, b) // 6 9

💡 예제
#include <stdio.h>
main(void) {
  int x = 7;
  int y = 7;
  int result = ++x + y--;
  printf("결과 : %d %d %d", result, x, y);
  return 0;
}
풀이방식

전위 연산자로 먼저 더하고, 후위 연산자로 행을 먼저 실행한 뒤 나중에 뺀다.

result = ++x + y-- : result = 8 + 7 =15

답

결과 :15 8 6

7) 복합 대입 연산자

산술 연산자와 대입(=) 연산자를 간결하게 사용하는 작업이다.

+= : a += 2 ⇒ a = a + 2

-= : a -= 2 ⇒ a = a - 2

*= : a *= 2 ⇒ a = a * 2

/= : a /= 2 ⇒ a = a / 2

%= : a %= 2 ⇒ a = a % 2

💡 예제

#include <stdio.h>
main(void) {
  int num = 13;
  num += 1;
  num -= 2;
  num *= 3;
  num /= 4;
  num %= 5;
  printf("결과 : %d", num);
  return 0;
}

풀이방식

num = 13 + 1 = 14
num = 14 - 2 = 12
num = 12 * 3 = 36
num = 36 / 4 = 9
num = 9 % 5 = 4
답
- 결과 :4

8) 삼항 연산자

조건이 부합할 경우, True와 False에 해당하는 값을 출력하는 연산자이다.

💡 구문

조건 ? True : False
// ? = 조건과 결과 구분
// : = 참과 거짓 구분

💡 예제
#include <stdio.h> 
main(void) {
  int a = 10;
  int b = 3;
  char result;
  result = a > b ? 'A' : 'B';
  printf("result : %c", result);
  return 0;
}
풀이방식

a > b이 True인 경우 A 출력

a > b이 False인 경우 B 출력

a > b = 10 > 3 = True

답

result :A

9) 진법 입력 및 출력 연산자

프로그래밍에서 기본적으로 10진법 형태의 숫자를 사용하지만, 다른 진법으로 표현하면 다음과 같다.
예시 값으로 10진수 134를 넣었다.

구분	C	Python	Java
입력	2진법 = 0b10000110	2진법 = 0b	2진법 = Integer.valueOf(int, 2)
	8진법 = 0	8진법 = 0o	8진법 = Integer.valueOf(int, 8)
	16진법 = 0x	16진법 = 0x	16진법 = Integer.valueOf(int, 16)
출력	10진법 = %d	2진법 = bin()	2진법 = Integer.toBinaryStrubg(int)
	8진법 = %o	8진법 = oct()	8진법 = Integer.toOctalString(int)
	16진법 = %x	16진법 = hex()	16진법 = Integer.HexString(int)
결과	10진법 = 134	2진법 = 0b10000110	2진법 = 10000110
	8진법 = 206	8진법 = 0o206	8진법 = 206
	16진법 = 86	16진법 = 0x86	16진법 = 86

💡 예제
// C
#include <stdio.h>
main(void) {
  int num = 0b11010;
  printf("10진수 : %d\n", num);
  printf("8진수 : %o\n", num);
  printf("16진수 : %x", num);
  return 0;
}
풀이방식 및 답

10진수 : 0b11010 = 16 + 8 + 2 = 26

8진수 : 26 = 3(8x3) + 2(2) = 32

16진수 : 26 = 1(16x1) + A(10) = 1A
# Python
num = 30
b = bin(num)
o = oct(num)
h = hex(num)
print(b)
print(o)
print(h)
풀이방식 및 답

2진수 : 30 = 1(16) + 1(8) + 1(4) + 1(2) + 0(1) = 0b11110

8진수 : 30 = 3(8x3) + 6(6) = 0x36

16진수 : 30 = 1(16x1) + E(14) = ox1E
// Java
public static void main(String[] args) {
  int i = 100;
  String b = Integer.toBinaryString(i)
  String o = Integer.toOctalString(i)
  String h = Integer.toHexString(i)
  System.out.println(b)
  System.out.println(o)
  System.out.println(h)
}
풀이방식 및 답

2진수 : 100 = 1(64) + 1(32) + 0(16) + 0(8) + 1(4) + 0(2) + 0(1) = 1100100

8진수 : 100 = 1(64x1) + 4(8x4) + 4(4) = 144

16진수 : 100 = 6(16x6) + 4(4) = 64

4. 명령문

프로그램으리 구성하는 문자. 지시 사항을 처리하는 단위이다.
기본적은 문법들의 종류가 많은 것은 아니며, 각 언어마다 유사한 문법 체계를 사용한다.

1) 조건문

조건의 참, 거짓 여부에 따라 실행 경로를 달리하는 if문과 여러 경로 중에 하나를 선택하는 switch case문으로 구분한다.

1-1) if, if-else 문

FORTRAN 에서 처음 사용하였으며, 현재 대다수의 프로그래밍 언어에서 기본 명령문으로 사용한다.
단순 if 문, 선택 if 문, 중첩if 문의 유형으로 구분된다.

// C & Java
if ( 조건 ) {
  실행문;
} else if ( 조건 ) {
  실행문;
} else {
  실행문;
}

# Python
if 조건:
  명령;
elif 조건:
  명령;
else:
  명령;

💡 예제 (if, if-else)
void main() {
  int num = 3;
  if ( num >= 5 ) {
    printf("Hello");
  } else if ( num >= 3 ) {
    printf("World");
  } else {
    printf("JaeJae");
  }
}
풀이과정

num >= 5 = 3 >= 5, False ⇒ 실행문 PASS

num >= 3 = 3 >= 3, True ⇒ 실행문 실행

참이 나온 이후 모든 조건 PASS

답

World

1-2) switch case 문

처음에만 조건이 동일한 case 문으로 간다.
따라서, break 가 없다면 처음에만 조건을 따지고, 이후에 나머지 case를 실행한다.

// C & Java
switch(변수) {
  case 값:
}
  실행문;
}

# Python
파이썬은 switch case문이 없지롱

💡 예제 1 (switch case)

#include <stdio.h>
int main() {
  int num = 1;
  switch(num) {
    case 1:
      printf("%d\n", num + 2);
      break;
    case 2:
      printf("%d\n", num + 1);
      break;
    case 3:
      printf("%d\n", num + 3);
      break;
    default:
      printf("%d\n", num);
      break;
  }
}

풀이과정

num = 1 ⇒ case 1
num + 2 = 1 + 2 =3
break 로 조건문 탈출
답
- 3

💡 예제 2 (switch case)

#include <stdio.h>
int main() {
  int num = 1;
  switch(num) {
    case 1:
      printf("%d\n", num + 2);
    case 2:
      printf("%d\n", num + 1);
    case 3:
      printf("%d\n", num + 3);
    default:
      printf("%d\n", num);
  }
}

풀이과정

break 가 없어서 모든 case 실행
num = 1 ⇒ case 1
num + 2 = 1 + 2 =3
num + 1 = 1 + 1 =2
num + 3 = 1 + 3 =4
default =1
답
- 3
- 2
- 4
- 1

2) 반복문

조건이 만족될 때까지 실행문을 반복적으로 실행하는 명령문
while, for, do-while 문이 있다.

💡 반복문

for( 초기값; 조건문; 증감문) {
  실행문;
}
// 초기값을 증감하여 조건문을 만족할 때까지 실행문을 반복적으로 실행한다.

while(조건문) {
  실행문;
}
// 조건문이 만족될 때까지 또는 break로 탈출할 때까지 실행문을 반복적으로 실행한다.

do {
  실행문;
} while(조건문);
// 조건과 맞지 않더라도 일단 한 번은 실행하고 조건문을 따진다.
// 해당 조건문을 만족할 때까지 do 구문을 반복한다.

3) 제어문

3-1) break, continue

일반적으로 특정 조건을 빠져나가기 위해 조건문 구문과 같이 사용하거나, 반복문 내에서 반복된 흐름을 벗어나기 위해 사용된다.

break : 해당 반복문을 멈추고, 탈출하는데 사용한다.
continue : 반복문을 유지하면서, 다음 반복으로 건너뛴다.

💡 예문
for(int i = 5; i >= 0; i--) {
  if( i % 2 == 0 ) {
    1) break; 
    2) continue;
  }
  printf("%d", i);
}
1)의 결과는 5

i = 5일 때 i % 2 == 0의 조건을 만족하지 않으므로 printf 문 출력

i = 4일 때 i % 2 == 0의 조건을 만족하므로 break, 반복문 탈출

실행 종료

2)의 결과는 531

i = 4일 때와 i = 2일 때 반복문은 유지하되 printf 문 뛰어넘음

따라서, i 가 5, 3, 1 일 때 printf 문 출력

3-2) 함수(Java)

중복된 코드의 사용을 방지하기 위하여, 메서드를 만들어서 필요할 때마다 호출하여 반환하는 역할을 한다.

💡 구문
자료형 함수명(타입 변수1, 타입 변수2, ...) {
  실행문;
  return 반환할 값;
}
여기서 return 에는 반환할 값을 넣기 때문에, return 값에 조건없이 함수명을 넣으면 무한 재귀가 될 수 있으니 조심하도록 하자.

💡 예문
int addFunction(int num1, int num2) {
  int sum = 0;
  sum = num1 + num2;
  return sum;
}
int main() {
  int result = addFunction(1,2);
  printf("%d", result);
}
addFunction 으로 1과 2 값을 인가함.

인가된 값으로 합연산을 한 뒤에 return의 반환값으로 넣는다.

해당 반환값을 result라는 정수형 변수에 대입하고 출력한다.

3

5. 사용자 정의 자료형

C/C++,Java 와 같은 프로그래밍 언어에서는 사용자가 직접 자료형을 만드는 것이 가능하다.

1) 열거체

괄호 안에 연속적인 값이 들어가는 자료형이다.
변수에 초기값을 지정하지 않으면 0이 된다.
이후 변수가 추가될 때마다 1씩 증가한다.

enum color {
  red,          // red = 0
  orange,       // orange = 1
  yellow=10,    // yellow = 10
  green,        // green = 11
}

2) 구조체

괄호 안에 멤버 변수를 사용하는 자료형이다.
구조체 내부에 멤버 변수의 자료형을 선언할 수 있고, 접근할 때는 .을 사용한다.

#include <stdio.h>
struct Language {
  int kor;
  int eng;
  int mat;
};
int main() {
  struct Language lag;
  lag.kor = 100;
  lag.eng = 90;
  lag.mat = 80;
  printf("%d %d %d", lag.kor, lag.eng, lag.mat);
}

3) 공용체

구조체와 거의 유사하나 조금 더 범주가 크다고 볼 수 있다.
메모리 공간을 공유하며 크기를 작게 사용하므로 임베디드나 통신 분야에서 많이 사용된다.

#include <stdio.h>
union School {
    int score;   // 점수용
    char grade;  // 등급용
};
int main() {
    union School sc;
    sc.score = 95;
    printf("점수: %d\n", ex.score);       // 1️⃣ 점수로 사용
    sc.grade = 'A';
    printf("등급: %c\n", ex.grade);       // 2️⃣ 같은 공간을 등급으로 해석
    printf("다시 점수: %d\n", lag.score);  // 3️⃣ 다시 점수로 보면?
    return 0;
}

출력

점수: 95
등급: A
다시 점수: 65

🚀 예상문제

1) 다음 C언어로 구현된 프로그램의 출력 결과를 쓰시오.

#include <stdio.h>

void main() {
  int a;
  int x = 5;
  int y = 5;
  
  a = --x + y++;
  
  printf('%d %d %d", a, x, y);
}

풀이과정 및 답

a = 4 + 5 = 9
y++ = 6
답 : 9 4 6

2) 다음 C언어로 구현된 프로그램의 출력 결과를 쓰시오.

#include <stdio.h>

void main() {
  int a, b, result1, result2;
  a = 12;
  b = 4;
  result1 = a&b;
  result2 = a|b;
  
  printf('%d\n", result1);
  printf('%d", result2);
}

풀이과정 및 답

result1 = a&b = 1100 & 0100 =0100
result2 = a|b = 1100 | 0100 =1100
답
- 4
- 12

3) 다음 JAVA로 구현된 프로그램의 출력 결과를 쓰시오.

class function{
  public static void main (String[] args) {
    int n = 5;
    System.out.println(fact(n));
  }
  
  public static int fact(int n) {
    if (n == 1) return 1;
    return n * fact(n-1);
  }
}

풀이과정

일단 이거 재귀함수임
n = 5일 때,
- return 5 * fact(4)
- n = 4일 때,
  - return 4 * fact(3)
  - n = 3일 때,
    - return 3 * fact(2)
    - n = 2일 때,
      - return 2 * fact(1)
      - n = 1일 때,
        
        return 1
      - 2 * 1 = 2
    - 3 * 2 = 6
  - 4 * 6 = 24
- 5 * 24 =120
답 : 120

4) 다음 C언어로 구현된 프로그램의 출력 결과를 쓰시오.

#include <stdio.h>

int main() {
  int a, sum;
  a = sum = 0;
  
  while( a <= 10 ) {
    a += 1;
    if(a % 2 == 1) continue;
    sum += a;
  }
  
  printf('sum = %d", sum);
  
  return 0;
}

풀이과정 및 답

a = 0 일 때 ⇒ 1 % 2 == 1 ⇒ continue
a = 1 일 때 sum = 0 + 2
a = 2 일 때 ⇒ 3 % 2 == 1 ⇒ continue
a = 3 일 때 sum = 2 + 4
(중략)
a = 9 일 때 sum = 20 + 10
a = 10 일 때 ⇒ 11 % 2 == 1 ⇒ continue
- while 문 종료
- sum = 30
답
- sum = 30

5) 다음 C언어로 구현된 프로그램의 출력 결과를 쓰시오.

#include <stdio.h>

int main() {
  enum subject {kuk, mat=5, eng};
  int a, b;
  a = sum = 0;
  
  a = kuk;
  b = eng;
  
  printf('a = %d\n", a);
  printf('b = %d", b);;
  
  return 0;
}

풀이과정 및 답

enum에서 kuk은 초기값이 없으므로 값은 0
enum에서 eng는 초기값이 5인 mat 다음이므로 값은 6
답
- a = 0
- b = 6

6) 다음의 출력 결과를 작성하시오.

#include <stdio.h>

void main() {
  int ary[5] = {47, 95, 64, 21, 66};
  int temp;
  
  for(int i = 0; i < 5; i++) {
    for(int j = 0; j < i; j++) {
      if(ary[i] < ary[j]) {
        temp = ary[i];
        ary[i] = ary[j];
        ary[j] = temp;
      }
    }
    
    for(int k = 0; k < 5; k++) {
      printf("%d", ary[k]);
    }
    printf("\n");
  }
}

풀이과정

i = 0 일 때
- 조건이 맞지 않아 두 번째 반복문은 PASS
- 세 번째 반복문은 배열 출력하는 반복문
- 47, 95, 64, 21, 66
- \n
i = 1 일 때
- j = 0 일 때
  - ary[1] < ary[0] = 95 < 47 ❌ ⇒ PASS
- 47, 95, 64, 21, 66
- \n
i = 2 일 때
- j = 0 일 때
  - ary[2] < ary[0] = 64 < 47 ❌ ⇒ PASS
- j = 1 일 때
  - ary[2] < ary[1] = 64 < 95 ✅ ⇒ 순서 바꾸기!
- 47, 64, 95, 21, 66
- \n
i = 3 일 때
- j = 0 일 때
  - ary[3] < ary[0] = 21 < 47 ✅ ⇒ 순서 바꾸기!
  - 21, 64, 95, 47, 66
- j = 1 일 때
  - ary[3] < ary[1] = 47 < 64 ✅ ⇒ 순서 바꾸기!
  - 21, 47, 95, 64, 66
- j = 2 일 때
  - ary[3] < ary[2] = 64 < 95 ✅ ⇒ 순서 바꾸기!
- 21, 47, 64, 95, 66
- \n
i = 4 일 때
- j = 0 일 때
  - ary[4] < ary[0] = 66 < 21 ❌ ⇒ PASS
- j = 1 일 때
  - ary[4] < ary[1] = 66 < 47 ❌ ⇒ PASS
- j = 2 일 때
  - ary[4] < ary[2] = 66 < 64 ❌ ⇒ PASS
- j = 3 일 때
  - ary[4] < ary[3] = 66 < 95 ✅ ⇒ 순서 바꾸기!
- 21, 47, 64, 66, 95
- \n
답
- 47, 95, 64, 21, 66
- 47, 95, 64, 21, 66
- 47, 64, 95, 21, 66
- 21, 47, 64, 95, 66
- 21, 47, 64, 66, 95

7) 다음의 출력 결과를 작성하시오.

#include <stdio.h>

void main() {
  int ary[5] = {47, 95, 64, 21, 66};
  int temp;
  
  for(int i = 0; i < 5; i++) {
    for(int j = 0; j < 5-i-1; j++) {
      if(ary[j] < ary[j+1]) {
        temp = ary[j];
        ary[j] = ary[j+1];
        ary[j+1] = temp;
      }
    }
    
    for(int k = 0; k < 5; k++) {
      printf("%d", ary[k]);
    }
    printf("\n");
  }
}

풀이과정

i = 0 일 때
- j = 0 일 때
  - ary[0] < ary[1] = 47 < 95 ✅ ⇒ 순서 바꾸기!
  - 95, 47, 64, 21, 66
- j = 1 일 때
  - ary[1] < ary[2] = 47 < 64 ✅ ⇒ 순서 바꾸기!
  - 95, 64, 47, 21, 66
- j = 2 일 때
  - ary[2] < ary[3] = 47 < 21 ❌ ⇒ PASS
- j = 3 일 때
  - ary[3] < ary[4] = 21 < 66 ✅ ⇒ 순서 바꾸기!
- 95, 64, 47, 66, 21
- \n
i = 1 일 때
- j = 0 일 때
  - ary[0] < ary[1] = 95 < 64 ❌ ⇒ PASS
- j = 1 일 때
  - ary[1] < ary[2] = 64 < 47 ❌ ⇒ PASS
- j = 2 일 때
  - ary[2] < ary[3] = 47 < 66 ✅ ⇒ 순서 바꾸기!
- 95, 64, 66, 47, 21
- \n
i = 2 일 때
- j = 0 일 때
  - ary[0] < ary[1] = 94 < 64 ❌ ⇒ PASS
- j = 1 일 때
  - ary[1] < ary[2] = 64 < 66 ✅ ⇒ 순서 바꾸기!
- 95, 66, 64, 47, 21
- \n
i = 3 일 때
- j = 0 일 때
  - ary[0] < ary[1] = 95 < 66 ❌ ⇒ PASS
- 95, 66, 64, 47, 21
- \n
i = 4 일 때
- 조건이 맞지 않아 두 번재 반복문은 PASS
- 95, 66, 64, 47, 21
- \n
답
- 95, 64, 47, 66, 21
- 95, 64, 66, 47, 21
- 95, 66, 64, 47, 21
- 95, 66, 64, 47, 21
- 95, 66, 64, 47, 21

8) 다음의 출력 결과를 작성하시오.

public class Path {
  public static void main(String[] args) {
    int[] arr = {4, 6, 9, 1, 2};
    insertionSort(arr);
  }
  
  public static void insertionSort(int[] arr) {
    int n = arr.length;
    
    for (int i = 1; i < n; i++) {
      int key = arr[i];
      int j = i - 1;
      
      while (j >= 0 && arr[j] > key) {
        arr[j + 1] = arr[j];
        j--;
      }
      
      arr[j + 1] = key;
      
      for (int element : arr) {
        System.out.print(element + " ");
      }
      
      System.out.println();
    }
  }
}

풀이과정

n = 5
i = 1 일 때
- key = arr[1] = 6
- j = 1 - 1 = 0
- while(0 >= 0 && 4 > 6) ❌ ⇒ PASS
- arr[1] = 6 = key
- 4, 6, 9, 1, 2
- \n
i = 2일 때
- key = arr[2] = 9
- j = 2 - 1 = 1
- while(1 >= 0 && 6 > 9) ❌ ⇒ PASS
- arr[2] = key = 9
- 4, 6, 9, 1, 2
- \n
i = 3일 때
- key = arr[3] = 1
- j = 3 - 1 = 2
- while(2 >= 0 && 9 > 1) ✅
  - arr[3] = 9 ⇒ 4, 6, 9, 9, 2
  - j--
    - while(1 >= 0 && 6 > 1) ✅
    - arr[2] = 6 ⇒ 4, 6, 6, 9, 2
    - j--
      - while(0 >= 0 && 4 > 1) ✅
      - arr[1] = 4 ⇒ 4, 4, 6, 9, 2
      - j--
- arr[0] = key = 1
- 1, 4, 6, 9, 2
- \n
i = 4일 때
- key = arr[4] = 2
- j = 4 - 1 = 3
  - while(3 >= 0 && 9 > 2) ✅
    - arr[4] = 9 ⇒ 1, 4, 6, 9, 9
    - j--
    - while(2 >= 0 && 6 > 2) ✅
    - arr[3] = 6 ⇒ 1, 4, 6, 6, 9
    - j--
      - while(1 >= 0 && 4 > 2) ✅
      - arr[2] = 4 ⇒ 1, 4, 4, 6, 9
      - j--
      - while(0 >= 0 && 1 > 2) ❌ ⇒ PASS
- arr[1] = key = 2
- 1, 2, 4, 6, 9
- \n
답
- 4, 6, 9, 1, 2
- 4, 6, 9, 1, 2
- 1, 4, 6, 9, 2
- 1, 2, 4, 6, 9

🍀 Section 2 | 프로그래밍 언어 특성

1. 프로그래밍 언어의 발전 과정 및 언어별 특성

년도	언어	특징
1960년대 이전	Assembly(1950년대)
	Fortran(1954년)	시스템 의존적
	LISP(1959년)
1960년대	Cobol(1960년대)	순차적 방식, 대문자로만 작성
	PL/I(1964년)
	Basic(1964년)
1970년대	Pascal(1971년)	사용자 정의 추상화 기능 O, 정보 은닉 기능 X
	C(1972년)	UNIX 운영체제, 포인터 타입
	Smalltalk(1972년)
	Prolog(1973년)
1980년대	ADA(1983년)
	C++(1983년)	C언어를 발전 킨 언. 객체 지향 언어(클래스, 상속 등)
	Python(1986년)	인터프리터 언어, 객체 지향 언어, 스크립트 언어
1990년대 이후	Ruby(1993년)
	Java(1995년)	분산 환경 및 보안성 지원. 가상 머신이 필요함
	JavaScript(1995년)	객체 지향 스크립터 언어. 웹 페이지 동작. 쉽지만 보안&성능이 상대적으로 부족
	C#(2000년)	.NET 환경에 맞춰 설계된 언어. C# 컴파일러를 필요로함.
	Golang#(2009년)	내장 라이브러리. 낮은 하드웨어 사양에도 빠른 컴파일 가능.
	Dart	JS와 Java의 영향을 받아 개발된 객체 지향 언어
	Ceylon	Java 기반 언어. Ceylon herd 라는 저장소에서 모듈을 발행

2. 프로그래밍 언어의 유형 분류

1) 개발 편의성에 따른 분류

저급 언어
- 기계가 이해할 수 있도록 만들어진 언어
- 추상화 수준이 낮고, 프로그램 작성이 어렵다.
- 기계어, 어셈블리어 등
고급 언어
- 개발자가 소스코드를 작성할 때 쉽게 이해할 수 있도록 만들어진 언어
- C, C++ Java 등

2) 실행 방식에 따른 분류 (명함논객)

명령형 언어
- 컴퓨터에 저장된 명령어들이 순차적으로 실행되는 프로그래밍 방식
- 절차형 언어
- Fortran, Cobol, Pascal, C 등
함수형 언어
- 수학적 수식과 같은 함수들로 프로그램을 구성하여 호출하는 방식
- LISP 등
논리형 언어
- 규칙에 대한 활성화 조건이 만족되면 연관된 규칙이 실행되는 구조
- 추론과 관계 규칙에 원하는 결과를 얻어내는 방식
- Prolog 등
객체 지향 언어
- 객체 간의 메시지 통신을 이용하여 프로그래밍 하는 방식
- Java, C++ 등

3) 구현 기법에 따른 분류 (컴인혼)

컴파일 방식의 언어
- 고급 언어를 기계어로 번역하는 방식의 언어
- 절차형 언어
- Fortran, Pascal, C, C++ 등
인터프리터 방식의 언어
- 고급 언어 명령문을 하나씩 번역하고 실행하는 방식의 언어
- Basic, Prolog, LISP, Snobol 등
혼합형 방식의 언어
- 고급 언어를 컴파일하여 중간 언어로 변환한 후 인터프리터에 의해 번역을 실행하는 방식의 언어
- Java 등

🚀 예상문제

1) 다음 중 1990년대 이후로 개발된 프로그래밍 언어가 아닌 것을 골라 쓰시오.

PYTHON
JAVA
C#
RUBY

답 : Python

2) 프로그래밍 언어 중 .NET환경에서 실행되기 때문에 .NET 환경의 설치가 요구되는 언어는 무엇인지 쓰시오.

답 : C#

3) 프로그램 언어 중 수학적 수식과 같은 함수로 이루어진 대표적인 함수형 언어는 무엇인지 쓰시오.

답 : LISP

🍀 Section 3 | 라이브러리

1. 라이브러리의 개념

1) 라이브러리 정의

효율적인 프로그램 개발을 위해 필요한 프로그램을 모아놓은 집합체
필요할 때 찾아서 사용할 수 있도록 모듈화 되어 제공되는 프로그램
프로그래밍 언어에 일반적으로 다음과 같은 기능을 제공한다.

도움말 : 라이브러리 어떻게 쓰는건지 알려주는 문서

설치 파일 : 라이브러리를 적용하기 위해 제공되는 설치 파일

샘플 코드 : 라이브러리를 이해하고 쉽게 적용하기 위해 제공되는 예시 코드

2) 라이브러리 종류

표준 라이브러리
- 프로그래밍 언어가 기본적으로 가지고 있는 라이브러리
- 별도의 파일 설치 없이 날짜와 시간 등의 기능을 사용할 수 있다.
외부 라이브러리
- 별도의 파일을 설치해야한다.
- 보통 표준 라이브러리 범위를 벗어나는 기능을 구현할 때 외부에서 불러오는 것이다.

3) 모듈과 패키지

라이브러리는 모듈과 패키지를 총칭한다.
모듈 : 개별 파일
패키지 : 개별 파일들을 모아놓은 폴더

Home  (패키지)
 ㄴ Board.js  (모듈)
 ㄴ Menu.js   (모듈)
 ㄴ Writhe.js (모듈)

2. 라이브러리의 활용(표준 C언어 라이브러리)

함수	헤더파일	설명	예
log	math.h	로그 계산	`double log(double a);`
log10	math.h	밑이 10인 로그 계산	`double log10(double a);`
pow	math.h	값 `a`의 `b`제곱 계산	`double pow(double a, double b);`
sqrt	math.h	제곱근 계산	`double sqrt(double a);`
tan	math.h	탄젠트 계산	`double tan(double a);`

abs	stdlib.h	정수 인수 `n`의 절대값 계산	`int abs(int n);`
atoi	stdlib.h	문자열을 정수로 변환	`int atoi(char str);`
malloc	stdlib.h	동적 메모리 할당	`void *malloc(size_t size);`
rand	stdlib.h	임의의 난수 생성	`int rand(void);`

strcat	string.h	`str2`를 `str1`에 연결	`char strcat(char str1, const char *str2);`
strcpy	string.h	`str2`를 `str1`에 복사	`char strcpy(char str1, const char *str2);`
strlen	string.h	`str` 문자열 길이 계산	`size_t strlen(const char *str);`

3. 라이브러리의 활용(표준 Java 라이브러리)

함수	설명	예
random()	0.0 이상 1.0 미만의 임이의 값 생성 및 반환	`Math.random()` //
abs	절댓값 반환	`Math.abs(10)` // 10
		`Math.abs(-10)` // 10
ceil	소수 부분 올리고 반환	`Math.ceil(10.1)` // 11.0
floor	소수 부분 버리고 반환	`Math.floor(10.1)` // 10.0
round	소수점 첫째 자리에서 반올림한 정수 반환	`Math.round(10.4)` // 10
		`Math.round(10.9)` // 11
rint	값과 가장 가까운 정수값 반환	`Math.rint(100.67)` // 101
		`Math.rint(10.34)` // 10
max	두 값 중 큰 값 반환	`Math.max(14, 11)` // 14
min	두 값 중 작은 값 반환	`Math.min(14, 11)` // 11
pow	첫 번째 인자값를 두 번째 인자값으로 제곱 연산하여 반환	`Math.pow(5, 3)` // 125
sqrt	값의 제곱근 반환	`Math.sqrt(25)` // 5

🚀 예상문제

1) 다음은 C언어로 구현된 1~10까지의 난수를 구하는 프로그램이다. 빈칸에 알맞은 라이브러리 함수를 입력하시오.

#include <stdio.h>
#include <stdlib.h>
  
int main() {
  printf("%d\n", (1 + (    )  % 10));
}

답 : rand 또는 rand()

2) 다음은 JAVA언어로 구현된 프로그램을 분석하여 그 실행 결과를 작성하시오.

class path {
  public static void main(String[] args) {
    System.out.printf("%d", (int)Maht.sqrt(25) + (int)Math.log(10));
  }
}

답 : 7

3) 다음의 출력 결과를 작성하시오.

public class test {
  public static void main(String[] args) {
    double a = 6.454;
    double b = 8.111;
    
    System.out.println(Math.ceil(a+b));
    System.out.println(Math.floor(a+b));
  }
}

답

15.0
14.0

강재훈

꿈을 향해 끊임없이 성장하기

이전 포스트

1. 프로그래밍 언어 활용 : 알고리즘 구현

다음 포스트

1. 프로그래밍 언어 활용 : 프로그래밍 언어 활용

정보처리기사 실기

📍 Chapter 2 : 프로그래밍 언어 활용

🍀 Section 1 | 프로그래밍 언어 활용

1. 프로그래밍 언어 활용의 개요

2. 프로그래밍 언어의 기본 문법 및 용어

3. 연산자

4. 명령문

5. 사용자 정의 자료형

🚀 예상문제

🍀 Section 2 | 프로그래밍 언어 특성

1. 프로그래밍 언어의 발전 과정 및 언어별 특성

2. 프로그래밍 언어의 유형 분류

🚀 예상문제

🍀 Section 3 | 라이브러리

1. 라이브러리의 개념

2. 라이브러리의 활용(표준 C언어 라이브러리)

3. 라이브러리의 활용(표준 Java 라이브러리)

🚀 예상문제

1. 프로그래밍 언어 활용 : 알고리즘 구현

2. 애플리케이션 테스트 수행 : 애플리케이션 테스트 수행

0개의 댓글