c 언어 시험공부 노트 - Hwanghyewon06/c- GitHub Wiki

#include <stdio.h>

int main()
{
    printf("정수 입력:");
    int n;
    scanf_s("%d", &n);
    printf("정수: %d\n", n);
}

라인별 설명:
1. #include <stdio.h>
stdio.h는 Standard Input Output Header의 줄임말로, printf, scanf 같은 입출력 함수를 쓰기 위해 꼭 필요해요.

2. int main() { ... }
C 프로그램이 시작하는 메인 함수예요.

여기서부터 실행이 시작돼요.

3. printf("정수 입력:");
화면에 "정수 입력:"이라는 글자를 출력해요.

사용자에게 정수를 입력하라고 알려주는 메시지죠.

4. int n;
정수형 변수 n을 선언해요.

사용자가 입력한 값을 여기에 저장할 거예요.

5. scanf_s("%d", &n);
사용자로부터 정수를 입력받아서 n에 저장해요.

%d는 정수를 입력받겠다는 뜻이에요.

&n은 n의 주소를 넘기는 거예요. (scanf는 입력받은 값을 변수에 넣어주려면 주소가 필요해요.)

scanf_s는 보안 강화 버전이에요. Visual Studio 같은 일부 컴파일러에서 권장하는 방식이에요.

scanf랑 거의 똑같지만, 문자열 입력 시 추가 인자(버퍼 크기)가 필요해요. 정수일 땐 추가 인자 없이도 사용 가능해요.

6. printf("정수: %d\n", n);
입력받은 정수 n을 화면에 출력해요.

예를 들어 사용자가 25를 입력했다면 출력은:

정수: 25



#include <stdio.h>

int main()
{
    printf("ABC 100\n");
    printf("ABC %d\n", 100);
    printf("ABC %d %d\n", 100, 200);
    printf("ABC %d %g\n", 100, 200.12);
}

라인별 해석:
1. #include <stdio.h>
표준 입출력 함수들을 사용하기 위해 stdio.h 헤더파일을 포함해요.

2. printf("ABC 100\n");
문자열 "ABC 100"을 그대로 출력해요.

\n은 줄 바꿈을 의미해요.

출력 결과:


ABC 100

3. printf("ABC %d\n", 100);
%d는 정수 (decimal)를 출력하는 포맷 문자예요.

100이라는 정수가 %d 자리에 들어가서 출력돼요.

출력 결과:

ABC 100

4. printf("ABC %d %d\n", 100, 200);
두 개의 %d가 있으니까, 정수 2개를 차례로 출력해요.

첫 번째 %d에 100, 두 번째 %d에 200이 들어가요.

출력 결과:


ABC 100 200

5. printf("ABC %d %g\n", 100, 200.12);
%d: 정수

%g: 실수를 간단하게 출력할 때 쓰는 포맷 문자예요. (%f보다 깔끔하게 표현)

100은 정수로 출력, 200.12는 실수로 출력돼요.

출력 결과:

ABC 100 200.12

전체 출력 결과:

ABC 100
ABC 100
ABC 100 200
ABC 100 200.12

#include <stdio.h>
int main()
{
	printf("ABC %d %d\n", 100, 200);
	printf("ABC %d %d\n", 100, 200);
	printf("ABC %d %d\n", 100, 200);
	printf("ABC %d %d\n", 100, 200);
	printf("ABC %d %d\n", 100, 200); // 정수 100과 200을 그대로 출력하는 코드예요
	int a = 100;
	int b = 200;  // 변수 a에는 100, b에는 200을 저장해요.
	printf("ABC %d %d\n", a, b); // 변수 a, b의 값을 출력해요. 위에서 100, 200으로 저장했으니까
	a = 1500;                    // 변수 a의 값을 1500으로 변경했어요 이제 a = 1500, b = 200
	printf("ABC %d %d\n", a, b);  // 이제부터 출력되는 값은 모두 a = 1500, b = 200
	printf("ABC %d %d\n", a, b);
	printf("ABC %d %d\n", a, b);
	printf("ABC %d %d\n", a, b);
	printf("ABC %d %d\n", a, b);
	printf("ABC %d %d\n", a, b); // 총 6번 반복
}

요약
printf는 값을 직접 넣을 수도 있고, 변수를 사용할 수도 있어요.

변수는 중간에 값을 바꿔줄 수 있고, 그 이후 출력에는 바뀐 값이 반영돼요.

이 코드는 그걸 반복해서 보여주는 거예요!


#include <stdio.h>
int main()
{
	printf("%d\n", 10);
	int n = 10; // 변수 n의 값을 10을 저장
	printf("%d\n", n);  // 출력되는 값은 10
}
  • 요약
변수 계산 결과
n 10 10
a 1 + 2 3
b 10 / 3 3 (소수점 버림) 

#include <stdio.h>
int main()
{
	int n = 10;
	int a = 1 + 2;
	int b = 10 / 3; // 정수끼리 나누면 소수점은 버려지고 정수 부분만 저장, 정수형 변수이므로 b = 3
	printf("%d\n", n);
	printf("%d\n", a);
	printf("%d\n", b);

}

#include <stdio.h>
int main()
{
	int n = 10;
	int a = 1 + 2;
	int b = 10 / 3; 
	printf("%d %d\n", n, sizeof(n)); 
	printf("%p %d\n", &n, sizeof(&n)); // %p: 포인터(주소)를 출력하는 포맷, sizeof(&n) → 주소 자체의 크기 (포인터 크기)
	printf("%d\n", a);                 // 보통 64비트 시스템이면 포인터는 8바이트
	printf("%d\n", b);

}
  • 요약
항목 의미 결과 (예시)
sizeof(n) int 변수 크기 4 (바이트)
&n n의 주소 ex) 0x7ffee98c6abc
sizeof(&n) 포인터 크기 8 (64비트 시스템 기준)
a 1 + 2 3
b 10 / 3 3 (소수점 버림)

주소도 데이터다? 네!

C 언어에서 주소 자체도 데이터예요. 그리고 이 주소는 포인터(pointer) 변수에 저장되는데, 이 포인터도 메모리에 저장되기 때문에 크기(byte 수)가 있어요.

시스템 종류 주소 길이 포인터 크기
32비트 시스템 4바이트 주소 4바이트 (sizeof(&n) → 4)
64비트 시스템 8바이트 주소 8바이트 (sizeof(&n) → 8)

산술 연산자

#include <stdio.h>
int main()
{
  //산술연산자
  int a = 10;
  int b = 3;

  printf("%d\n", a + b);  
  int result = a + b; //a + b 계산 결과인 13을 변수 result에 저장
  printf("%d\n", result); //변수 result 값 출력 → 13

  printf("%d\n", a - b); //출력: 7
  printf("%d\n", a * b); // 출력: 30
  printf("%d\n", a / b); // 출력: 3
  printf("%d\n", a % b); // 출력: 1
}
  • 요약
연산자 의미 예시 결과
  • | 덧셈 | 10 + 3 = 13
  • | 뺄셈 | 10 - 3 = 7
  • | 곱셈 | 10 * 3 = 30 / | 나눗셈(몫) | 10 / 3 = 3 % | 나머지 | 10 % 3 = 1
#include <stdio.h>
int main()
{
	//단항 연산자(++, --)
	int a = 10;
	int b = 3;

	++a; // ++a;전위 증가 연산자 a의 값을 1 증가시켜요.즉, a = 11이 돼요.
	printf("%d\n", a);
	a = a + 1;   // a에 다시 1을 더해요. a = 11 + 1 = 12
    printf("%d\n", a);
}

단항 연산자

  • 요약
표현 설명 결과
++a; a를 1 증가 a = 11
a = a + 1; a에 1 더해서 저장 a = 12 

#include <stdio.h>
int main()
{
  int a = 10;
  int b = 0;

  b = ++a; //전위 증가 연산자 → 먼저 a를 1 증가시킨 후, 그 값을 b에 대입 a = 11, b = 11
 //b = a++; 후위 증가 연산자 먼저 a의 현재 값(10)을 b에 대입 b = 10,  a를 1 증가시킴 → a = 11
  printf(" %d %d\n ", a, b);
}
  • 요약
코드 실행 순서 결과 (a, b)
b = ++a; a 먼저 증가 → 그 값 b에 저장 11, 11
b = a++; a 먼저 사용해서 b에 저장 → 그 후 증가 11, 10

논리 연산자

#include <stdio.h>
int main()
{
  //논리 연산자(값)
  int a = 1;
  int b = 0;

  printf("%d\n", a && b); //and 둘 중 하나라도 거짓이면 결과는 거짓 (0)
  printf("%d\n", a || b); //or 하나라도 참이면 결과는 참 (1)
  printf("%d\n", !a); //not 참을 반대로 뒤집으면 → 거짓 (0)
  printf("%d\n", !b); //not 거짓을 반대로 뒤집으면 → 참 (1)
}
  • 요약
연산 결과 이유
a && b 0 둘 다 참이 아니니까 false
`a b`
!a 0 a는 참(1), NOT → false(0)
!b 1 b는 거짓(0), NOT → true(1) 
#include <stdio.h>
int main()
{
  int n = 10;

  printf("%d , %d\n", sizeof(int), sizeof(n));
}
  • 요약
항목 의미 결과 (보통)
sizeof(int) int 타입의 크기 4 bytes
sizeof(n) 변수 n의 실제 크기 4 bytes
표현 의미 값
sizeof(int) int라는 자료형이 차지하는 크기 4 바이트 (보통)
sizeof(n) n 변수는 int 타입이니까 역시 4 바이트 4 바이트

다른 자료형 크기

자료형 크기 (일반적인 시스템 기준)
char 1 byte
short 2 bytes
int 4 bytes
float 4 bytes
double 8 bytes
long 4 or 8 bytes (환경에 따라 다름) 
#include <stdio.h>

int main()
{
  char c = 10;
  short s = 10;
  int n = 10;
  long l = 10;
  float f = 10;
  double d = 10;

  printf("%d , %d\n", sizeof(char), sizeof(c));
  printf("%d , %d\n", sizeof(short), sizeof(s));
  printf("%d , %d\n", sizeof(int), sizeof(n));
  printf("%d , %d\n", sizeof(long), sizeof(l));
  printf("%d , %d\n", sizeof(float), sizeof(f));
  printf("%d , %d\n", sizeof(double), sizeof(d));
}

한 줄씩 쉽게 해석

변수 자료형 저장 값 의미
c char 10 1바이트 문자 자료형 (정수도 저장 가능)
s short 10 2바이트 정수형 (작은 정수 저장용)
n int 10 기본 정수형
l long 10 큰 정수 저장용
f float 10.0 실수형 (단정도, 소수점)
d double 10.0 실수형 (배정도, 더 정밀한 소수)

정리 요약

표현 의미 결과 (보통)
sizeof(char) char 타입의 크기 1 byte
sizeof(c) 변수 c의 크기 (char니까) 1 byte
sizeof(short) short 타입의 크기 2 bytes
sizeof(int) int 타입의 크기 4 bytes
sizeof(long) long 타입의 크기 (64비트면 8 bytes) 8 bytes
sizeof(float) float 타입의 크기 4 bytes
sizeof(double) double 타입의 크기 8 bytes 
#include <stdio.h> 

int main() 
{ 
  char n = 10; 
 
  printf("%p , %d\n", &n, n); 
  printf("%p , %d\n", &n+1, n+1); 
}
  • 요약 표
표현 의미 예시 결과
&n 변수 n의 주소 0x1000 (예시 주소)
n 변수 n의 값 10
&n + 1 n의 주소에서 1바이트 뒤 0x1001
n + 1 값 10에 1 더한 결과 11

if문

#include <stdio.h> 
int main() 
{ 
  if (1) 
  { 
    printf("Hello True\n"); 
  } 
  if (0) 
  { 
    printf("Hello False\n"); 
  } 
}
  • 요약
조건 의미 실행 여부 출력 내용
if (1) 항상 참 실행함 Hello True
if (0) 항상 거짓 실행 안 함 (아무 것도 없음)

참고

값 판단
0 거짓 (false)
1 참 (true)
-1 참 (true)
100, 9999, ... 전부 참 (true)

if - else문

#include <stdio.h> 
int main() 
{ 
  if (1) 
  { 
    printf("Hello True\n"); 
  } 
  else 
  { 
    printf("Hello False\n"); 
  } 
}
  • 요약
조건 실행되는 부분 출력 내용
참 if 블록 실행 Hello True
거짓 else 블록 실행 Hello False

참고

표현 의미
if (1) 참 → 실행
if (0) 거짓 → 실행 안 함
if (a > b) a가 b보다 크면 실행 
#include <stdio.h> 
int main() 
{ 
  int a = 10; 
  int b = 5;

  if ( a < b ) 
  {
    printf("Hello True\n"); 
  } 
  if ( a >= b ) 
  { 
    printf("Hello False\n"); 
  } 
}
  • 요약
조건식 결과 실행 여부
a < b false (거짓) 실행 안 됨
a >= b true (참) 실행됨

비교 연산자

#include <stdio.h>
int main()
{
	//비교연산자
	int a = 10;
	int b = 3;

	printf("%d\n", a == b);
	printf("%d\n", a != b); 
	printf("%d\n", a > b); 
	printf("%d\n", a < b); 
	printf("%d\n", a >= b);
	printf("%d\n", a <= b);
}
연산자 의미
< 작다

| 크다 <= | 작거나 같다 = | 크거나 같다 == | 같다 != | 같지 않다

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

switch (값) {
  case 값1:
    // 실행할 코드
    break;
  case 값2:
    // 실행할 코드
    break;
  ...
  default:
    // 위에 아무것도 해당 안 될 때 실행
    break;
}

// #include <conio.h> // 이건 지금 코드에선 필요 없음

int main()
{
  switch ('1' - '0')
  {
  case 1:
    printf("Hello : %d\n", 1);
    break;
  case 2:
    printf("Hello : %d\n", 2);
    break;
  case 3:
    printf("Hello : %d\n", 3);
    break;
  default:
    printf("default\n");
    break;
  }
}

참고: 왜 '1' - '0'을 쓰나요?

키보드에서 문자 '1'을 입력했을 때, 이를 숫자 1로 바꾸고 싶을 때 자주 씁니다!

#include <conio.h>  // _getch() 함수 사용을 위한 헤더

int main()
{
  switch (_getch() - '0')
  {
  case 1:
    printf("Hello : %d\n", 1);
    break;
  case 2:
    printf("Hello : %d\n", 2);
    break;
  case 3:
    printf("Hello : %d\n", 3);
    break;
  default:
    printf("default\n");
    break;
  }
}

포인트별로 해석

_getch() 콘솔에서 키보드 입력을 1개 즉시 읽어오는 함수예요.

엔터 없이도 키 하나만 누르면 바로 값이 들어옵니다.

conio.h 헤더파일이 필요합니다. (Windows 전용)

_getch() - '0' 예를 들어 사용자가 '2'(문자 2)를 눌렀다면:

'2'의 아스키 값은 50

'0'의 아스키 값은 48

50 - 48 = 2

즉, 입력한 문자 숫자를 정수로 바꾸는 역할을 해요!

#include <stdio.h>
int main()
{
  for (int i = 0; i < 5; ++i)
  {
    printf("[%d] : %d\n", i, i+1);
  }
}

한 줄씩 해석

for (int i = 0; i < 5; ++i) 반복 변수 i를 0부터 시작해서,

i < 5일 동안 반복합니다.

반복할 때마다 i는 1씩 증가 (++i).

즉, i는 0 → 1 → 2 → 3 → 4까지 진행되고, 총 5번 반복합니다.

printf("[%d] : %d\n", i, i+1); 이 줄은 i와 i + 1을 함께 출력하는 부분입니다.

[%d] → 현재 반복 횟수(i)

: %d → i + 1 값 출력

\n → 줄 바꿈

요약

반복 횟수 i 출력 결과
0 [0] : 1
1 [1] : 2
2 [2] : 3
3 [3] : 4
4 [4] : 5 
#include <stdio.h>

int main()
{
  int i = 0;

  while ( i < 5 )
  {
    printf("[%d] : %d\n", i, i + 1);
    ++i;
  }
}

한 줄씩 쉽게 해석

int i = 0; 변수 i를 선언하고 초기값으로 0을 설정합니다.

이 변수는 반복 횟수를 세는 데 사용됩니다.

while (i < 5) 조건: i가 5보다 작을 동안 계속 반복!

즉, i = 0, 1, 2, 3, 4일 때까지 총 5번 반복합니다.

흐름 요약

반복 전 i 값 출력 결과 반복 후 i 값
0 [0] : 1 1
1 [1] : 2 2
2 [2] : 3 3
3 [3] : 4 4
4 [4] : 5 5 → 조건 종료

for vs while

for 문은 반복 조건, 변수 초기화, 증가를 한 줄에 씁니다.

while 문은 더 직관적이고 단계별로 분리해서 보는 연습에 좋아요!

#include <stdio.h>
#include <conio.h>

int main()
{
  while (1) // 무한 루프 시작
  {
    printf("문자 입력(종료:q) : ");
    
    char c = _getch(); // 사용자로부터 문자 하나 입력 (화면에 안 보임)
    
    if (c == 'q') // 입력한 문자가 q이면
      break;      // 반복 종료

    printf("Hello : %c\n", c); // 입력한 문자 출력
  }
}

#포인트 해석

while (1) 조건이 항상 참이므로 무한 반복합니다.

종료는 직접 break; 문으로 제어합니다.

_getch() 키보드로 한 글자 입력 받음

Enter 없이도 즉시 입력됨

콘솔에 입력한 문자는 보이지 않음

→ 이건 conio.h에서 제공하는 함수이고 Windows 전용이에요.

if (c == 'q') 입력한 문자가 'q'이면 반복을 끝냅니다.

→ break;로 while문을 빠져나감

printf("Hello : %c\n", c); q가 아닌 다른 문자를 입력했을 경우,

그 문자를 포함해서 출력: "Hello : <입력한 문자>"

요약

입력 문자 동작
'a' Hello : a 출력하고 반복 계속
'b' Hello : b 출력하고 반복 계속
'q' 조건 만족 → break → 프로그램 종료 
#include <stdio.h>
#include <conio.h>

int main()
{
  int run = 1;  // 반복을 제어할 변수, 처음엔 1(참)

  while (run)
  {
    printf("문자 입력(종료:q) : ");

    char c = _getch();  // 문자 1개 입력 (콘솔에 표시 안 됨)

    if (c == 'q')       // 입력한 문자가 'q'면
      run = 0;          // run을 0으로 → while 종료 조건
    else
      printf("Hello : %c\n", c);  // q가 아니면 출력
  }
}

한 줄씩 쉽게 설명

int run = 1; 무한 루프를 제어할 변수입니다.

1이면 계속 실행, 0이면 종료.

while (run) run이 1일 동안 반복 (조건이 참일 동안 계속 실행됨)

char c = _getch(); 키보드에서 문자 하나 입력받음 (즉시, 콘솔에 안 보임)

예: 사용자가 a를 누르면 c에는 'a'가 저장됨

if (c == 'q') 입력한 문자가 q라면 → run = 0 → while 조건이 거짓이 됨 → 반복 종료

else printf("Hello : %c\n", c); q가 아니면 입력한 문자를 출력함.

핵심 차이점: break vs run

방법 설명
break; 반복문을 즉시 빠져나감
run = 0; 조건 변수 변경 → while(run) 종료됨

반복문: 1~10까지 숫자 체크

for (int i = 1; i <= 10; i = i + 1)
{
  if (i % 2 == 0)
    printf("even : %d\n", i);

  if (i % 2 == 1)
    printf("odd : %d\n", i);
}

odd : 1 even : 2 odd : 3 even : 4 ... even : 10

덧셈 예제 (sum 값 변화)

int sum = 0;
printf("sum = %d\n", sum);

sum = sum + 1;
printf("sum = %d\n", sum);

sum = sum + 2;
printf("sum = %d\n", sum);

sum = sum + 3;
printf("sum = %d\n", sum);

출력 결과

sum = 0 sum = 1 sum = 3 sum = 6

기본 코드: 1~10까지 합 계산

#include <stdio.h>

int main()
{
  int sum = 0;

  for (int i = 1; i <= 10; i++)
  {
    sum = sum + i;  // 또는 sum += i;
  }

  printf("1부터 10까지의 총합: %d\n", sum);
}

참고: 수학 공식 사용도 가능

1부터 n까지의 합 = n * (n + 1) / 2 예: 10 * (10 + 1) / 2 = 55

int n = 10;
int sum = n * (n + 1) / 2;

짝수 합, 홀수 합 구분 코드

#include <stdio.h>

int main()
{
  int even_sum = 0; // 짝수 합
  int odd_sum = 0;  // 홀수 합

  for (int i = 1; i <= 10; i++)
  {
    if (i % 2 == 0)
      even_sum += i;  // 짝수면 even_sum에 더함
    else
      odd_sum += i;   // 홀수면 odd_sum에 더함
  }

  printf("짝수 합 : %d\n", even_sum);
  printf("홀수 합 : %d\n", odd_sum);
}

실행 결과

짝수 합 : 30 홀수 합 : 25

함수 정의

#include <stdio.h>

void PrintHello(int size)
{
  for (int i = 0; i < size; ++i)
    printf("Hello: %d\n", i + 1);

  puts("");  // 줄 바꿈 (빈 줄 출력)
}

int main()
{
  PrintHello(2);
  PrintHello(3);
  PrintHello(10);
}

한 줄씩 코드 해석

void PrintHello(int size)
PrintHello라는 함수를 정의함

size만큼 "Hello: 숫자"를 출력함

for (int i = 0; i < size; ++i)
i를 0부터 시작해서 size보다 작을 동안 반복

printf("Hello: %d\n", i + 1);
반복하면서 Hello: 1, Hello: 2, ... 이런 식으로 출력

puts("");
빈 줄 출력

줄 바꿈만 하고, 아무 글자도 출력하지 않음

다음 호출 출력과 구분하기 위해 사용됨

main() 함수에서

PrintHello(2);
PrintHello(3);
PrintHello(10);

위에서 만든 함수 PrintHello()를 세 번 호출함

첫 번째는 2번

두 번째는 3번

세 번째는 10번 출력

전체 출력 결과

Hello: 1
Hello: 2

Hello: 1
Hello: 2
Hello: 3

Hello: 1
Hello: 2
Hello: 3
Hello: 4
Hello: 5
Hello: 6
Hello: 7
Hello: 8
Hello: 9
Hello: 10

요약

PrintHello(size) → size번 반복해서 "Hello: n" 출력

puts("") → 출력 구분용 빈 줄

⚠️ **GitHub.com Fallback** ⚠️