크흠.... 기존 학교에서 배운 것들을 티스토리에 요약하고, 컴퓨터에서 삭제하려는 목적으로 '컴퓨터공학' 카테고리를 만들었습니다.

그런데 이렇게 3년이 흘러버리니 1학년 때 적어둔 것들이 어떤 순서로 필기된건지 모르겠더군요. 순서가 뒤죽박죽이어서 후에 배울 것들을 앞 장에서 응용하고 있다 보니 게시글의 순서가 뒤죽박죽이 되어 버렸습니다.

티스토리의 경우 게시된 날짜를 기준으로 정렬되는 듯하여 모든 정리가 끝나면 다시 한번 순서를 조절하도록 하겠습니다.

변수의 크기 알아보기

우선 이전 장([컴퓨터공학/C] : 2장-1 자료형)에서 각 자료형이 몇 Bytes의 크기인지 배웠습니다. 실제로 프로그래밍을 할 때 변수들의 크기가 중요합니다. 뒤에 배우게 될 구조체도 크기를 아는 것이 중요합니다.

간단한 정수형이나 실수형 변수의 크기는 외울 수 있다고 하더라도 프로그래머가 직접 구현하는 구조체의 크기까지 외울 수 있을까요? 아마 불가능할겁니다.

그래서 sizeof();연산자가 있습니다.

이 연산자는 함수가 아닙니다. 연산자입니다. 왜냐하면 프로그램이 실행될 때 sizeof();를 실행해서 크기를 계산하는 게 아니고, 프로그램을 컴파일 할 때 컴파일러가 size를 계산해서 상수로 바꿉니다. 그러니까 크기를 외워서 크기를 입력하는 것과 sizeof(); 연산자를 사용하는 것은 성능상에 차이가 없다는 의미입니다.
상수가 뭔지도 추후에 배울 예정입니다. 상수는 코드를 읽기 쉬우면서 프로그램은 가볍게 만들기에 유리합니다.

#include <stdio.h>
void main(){
    char x;
    float y;

    printf("변수 x의 크기  %d\n", sizeof(x));        //<- printf("변수 x의 크기 %d\n", 1); 과 성능 차이 전혀 없음
    printf("변수 y의 크기 %d\n", sizeof(y));
    printf("double의 크기%d\n", sizeof(double));
}

이런 식으로 활용하게 됩니다. sizeof();는 연산자가 아니기 때문에 파라미터의 형식도 상관 없고, 그게 심지어는 자료형이라도 작동합니다.

오버플로우(OverFlow)와 언더플로우(UnderFlow)

변수의 크기를 알 필요가 있는 가장 큰 이유입니다. 제대로 말하자면 조금 다릅니다. 정확한 표현으로는 오버플로우와 sizeof()를 자주 사용해야 하는 이유가 같습니다.

Overflow란, 직역 의미 그대로 넘쳐 흐른다는 의미입니다. 변수의 크기가 너무 커서 변수의 공간 안에 저장할 수 없는 경우이죠. Underflow는 반대의 의미입니다. 너무 작아서 변수의 공간 안에 담을 수 없는 경우입니다.
2장-1에서 배우기로 char형은 1 Byte 크기를 가지고 있고 -128~127의 범위를 갖고 있습니다. 그리고 1 Byte는 8 bits로 구성되어 있습니다.
만약 127을 char형 변수에 저장한다면 실제로는 0111 1111로 저장됩니다. 그리고 여기에 1을 더하면 1000 0000이 되죠. 그 값은 - 128입니다. 이런 것을 Overflow라 합니다. 반대로 -128에서 1을 빼면 127이 되는 현상을 Underflow라고 합니다.

그런데 궁금한게 있습니다! 이전 장에서도 변수의 범위까지는 언급을 했지만 왜 1000 0000이 -127이 되는지는 말하지 않았습니다. 상식적으로 맨 앞이 부호를 표시한다면 1111 1111이 -128이 되어야 하지 않을까요?
컴퓨터는 구조상 뺄셈 연산을 하지 못합니다. 구조를 단순화 하기 위해, 뺄셈은 음수를 더하는 연산을 하죠. 그래서 음수의 표현보다는 음수의 연산에 초점을 맞춰서 개발한 표현방식입니다. 이런 음수의 표현을 '2의 보수'라고 합니다.

127과 -127를 더하면 그 값은 0이 됩니다. 사람이 생각하는 대로 표현했다면 0111 1111 + 1111 1111은 1 0111 1110이라는 이상한 숫자가 나옵니다. 8 Bits 공간을 가지고 있기 때문에 Overflow는 버리고 0111 1110이 됩니다.

하지만 2의 보수를 만들어주면 덧셈이 쉬워집니다. 2의 보수는 양수에서 각 자릿수마다 ~(NOT)연산을 하고 1을 더한다고 보면 됩니다. 그러니까 0111 1111의 2의 보수를 만들면 1000 0001이 -127이 됩니다. 두 수를 덧셈 연산하면 1 0000 0000이 되죠. 위에서와 같이 Overflow를 버리면 0이 됩니다!

변수의 최댓값과 최솟값

변수의 크기는 알았는데, 그럼에도 최댓값과 최솟값은 알아야 Overflow를 방지할 수 있는것 아닌가요? 그래서 몇몇 변수에 대해서 최댓값과 최솟값을 미리 정의해둔 헤더가 있습니다. limits.h인데요, 여기서 CHAR_MIN, CHAR_MAX, UINT_MIN, UINT_MAX 등의 표현으로 정의되어 있습니다. 바로 사용해볼까요?

#include<stdio.h>
#include<limits.h>

void main(){
    char x = CHAR_MAX;
    printf("MAX of CHAR : %d \n", x);
    char y= x+ 1;
    printf("Overflow : %d \n", y);
    printf("127+(-128)  = %d\n", x+y);                 //출력은 -1이 됩니다.
}

이런 식으로 사용할 수 있는겁니다. char의 최댓값을 저장하면 127이 됩니다. 그리고 Overflow된 값(-128)을 y에 저장합니다. 그리고 이 두 수를 더하면 -1이 됩니다.

요약

• 변수의 크기를 알 수 있다.
• 오버플로와 언더플로를 이해할 수 있다.
• 2의 보수를 이해하고, 음수와의 연산에서 오버플로와 언더플로를 활용하는 것을 알 수 있다.
• 변수의 최댓값과 최솟값이 정의된 헤더를 불러올 수 있다.

변수의 크기를 알아야 하는 이유?

마지막으로 한 가지 더!

오버플로를 설명하면서 변수의 크기를 알아야 하는 이유라고 언급했습니다. 하지만 아무리 생각해봐도 관련성이 없어보입니다. 나중에 배열, 포인터나 주소의 개념을 갖고 나면 이해가 될 부분입니다. C언어는 LowLevel언어이기 때문에 메모리 주소에 직접 접근할 수 있습니다. 그만큼 프로그램이 빠르지만 프로그래머가 메모리를 고려해야 하는 단점이 있습니다.

예를 들어서 char형의 변수가 5개로 구성된 배열 name이 있습니다. 이 변수는 1 Byte 변수가 5개가 있는 것이고, 총 5 Bytes로 구성됩니다. name의 주소가 0x0020이라고 하면, 첫번째 칸은 0x0020이고, 다섯번째 칸은 0x0025가 됩니다.
그런데 프로그래머가 6번째 배열에 접근하려고 하면 C언어는 0x0026에 접근합니다. name을 통해 접근할 수 있는 주소의 범위는 0x0020~0x0025까지인데, 이에 상관없이 0x0026에 접근하는 겁니다. 물론 이런 비정상적인 접근은 OS에서 차단하고 프로그램을 강제 종료합니다. 계속 실행되면 다른 프로그램의 정보를 탈취할 수 있기 때문에 아예 종료해버리는 겁니다.

출처 : reddit.com
그 결과가 이겁니다. 옛날에는 시도 때도 없이 보던 겁니다. 수 년이 지나면서도, Windows가 업데이트 되고 업그레이드 되면서도 꾸준히 보던 경고입니다. 지금 보니 메모리 접근을 고려하는게 얼마나 어려운지 아시겠죠?

물론 다른 고급 언어들도 비슷합니다. 객체 지향 언어들도 배열은 같거든요. 하지만 대부분은 객체를 사용합니다. 그리고 그 객체는 리스트(배열 개념을 객체로 표현한 것이다. C언어는 Linked List(연결리스트)로 구현할 수 있다.)와 리스트의 갯수까지 갖고 있기 때문에 프로그래머는 마지막 변수가 필요할 때, 리스트의 크기를 가져오면 됩니다.

리스트의 개념은 C언어에서도 구조체를 이용해 연결리스트로 표현이 가능합니다. 단지 구현 방법이 좀 다를 뿐이죠. 이는 후에 배열, 포인터 부분에서 학습하게 됩니다.

다음에는 진수의 표현에 대해서 올리도록 하겠습니다.

비트 연산, 시프트 연산, 연산 순서

2장 자료형에서 비트에 대한 얘기를 잠깐 하고 지나갔었죠?

컴퓨터는 모든 데이터를 0과 1로 저장합니다. 그걸 bit라고 하죠. 2진수로 볼 수 있습니다.
비트를 이용해 표현할 수 있는 수는 아래와 같습니다.

1비트로는 0, 1.
2비트로는 00, 01, 10, 11.
3비트로는 000, 001, 010, 011, 100, 101, 110, 111.

int는 4bytes(32bits)로 표현되는 정수입니다.

그런데 이런 데이터를 산술 연산이 아닌 bit끼리 비교하는 방법이 있습니다. 그걸 비트 연산이라고 합니다.
뭐랄까, 메모리의 데이터를 그대로 비교한다는 느낌일까요?

그래서 비트 연산은 사칙 연산이 아닌 다른 연산을 할 때 주로 사용합니다. AND, OR, XOR, NOT, 그리고 시프트 연산이 있습니다.

AND, OR, XOR, NOT 연산

비트 연산에 적용하기 전에 이 연산자들이 어떤 연산을 하는지 먼저 알아보도록 하겠습니다.

보통 비트 연산에서는 0이 거짓, 1이 참이라고 생각하면 편하게 계산할 수 있습니다.

AND(&)연산은 두 비트가 모두 1일 경우에 결과값이 1이 됩니다. a & b는 a와 b 모두 참인지 물어보는 연산이라고 생각하면 됩니다.

0 & 0 = 0
0 & 1 = 0
1 & 0 = 0
1 & 1 = 1

OR(|)연산은 두 비트 중 하나라도 1일 경우에 결과값이 1이 됩니다. a | b는 a나 b 둘 중 하나라도 참인지 물어보는 연산입니다.

0 | 0 = 0
0 | 1 = 1
1 | 0 = 1
1 | 1 = 1

XOR(^)연산은 두 비트가 같으면 결과값이 1이 됩니다.

0 ^ 0 = 0
0 ^ 1 = 1
1 ^ 0 = 1
1 ^ 1 = 0

NOT(~)연산은 좀 다릅니다. 두 데이터를 비교하는 게 아닌, 하나의 데이터를 반전하는 연산입니다.

0 = 0
1 = 1
~0 = 1
~1 = 0

컴퓨터에서 비트 연산

변수는 1비트로 이루어져 있지 않습니다. 참과 거짓만을 저장하는 boolean을 제외하고 가장 작은 자료형이 char입니다. 1byte 자료형이고, 비트로는 8bits입니다.

그렇다면 여러 자리의 bits는 어떻게 연산할까요? 이 글의 초반에 메모리의 데이터를 그대로 비교하는 느낌이라고 했던 것 기억하시나요? 비트 연산을 할 때, 컴퓨터는 메모리의 값이 어떤 의미를 가지고 있는지는 상관하지 않습니다. 단지 하나의 bit 끼리만 비교하는 거지요.

여기, 1 byte크기의 데이터가 두 개 있습니다.

각각 a=0010 0101(정수 37), b=1000 0110(정수 -122) 라고 해보지요. 1 byte는 8 bits데이터입니다. 8 bits 크기의 데이터를 하나의 bit 끼리 비교한다면 각 자리별로 총 8번 'bit 연산'을 수행하면 됩니다.

이제 두 데이터 a와 b를 AND, OR, XOR, NOT연산을 해보겠습니다.

AND 연산

a = 0010 0101(37)
&
b = 1000 0110(-122)

A = 0000 0100(4)

OR 연산

a = 0010 0101(37)
|
b = 1000 0110(-122)

A = 1010 0111(-89)

XOR 연산

a = 0010 0101(37)
^
b = 1000 0110(-122)

A = 1010 0011(-93)

NOT 연산

a = 0010 0101(37)
~a = 1101 1010(-38)

b = 1000 0110(-122)
~b = 0111 1001(121)

NOT연산은 정수값을 보니 어떤 의미인지 좀 보이지 않나요?ㅎㅎ

Shift(시프트 연산)

비트 연산은 메모리의 데이터가 의미하는 바에 상관 없이 비트 끼리만 연산하는 거라고 했습니다.

그렇다면 그 비트를 왼쪽이나 오른쪽으로 옮기는 연산도 있지 않을까요?

그것을 Shift 연산이라고 합니다.

#include<stdio.h>
void main(){
    int i = 64;
    i = i << 1;

    printf("%d", i);

    i = i >> 1;

    printf("%d", i);
    return ;  
}

와 같은 형식으로 쓰입니다.

그런데 이 연산의 결과가 재미있습니다.

값이 64인 i를 왼쪽으로 한 번 시프트하면 i는 원래의 두 배인 128이 됩니다. 두 번 시프트 하면 256이 되죠. 반대로 오른쪽으로 시프트하면 128, 그리고 64가 됩니다.

한 번 왼쪽으로 시프트하면 값이 두 배가 됩니다. 오른쪽으로 한번 시프트 연산을 하면 값이 반이 됩니다. 어떻게 이런 결과가 나올까요? 바로 이진법의 원리 때문입니다.

이진법으로 숫자를 써보면 아래와 같습니다.

1 = 0000 0001
2 = 0000 0010
4 = 0000 0100
8 = 0000 1000
32 = 0010 0000
128 = 1000 0000(unsigned char)
-128 = 1000 0000(signed char)

-128인 이유는 '2의 보수' 개념을 사용하기 때문입니다. 2장-2글을 참고하세요

앗, 그러면 두 배를 곱할 때는 i = i * 2; 보다는 i = i << 1;이 빠르지 않을까요? 논리적으로는 맞습니다. 그런데 굳이 그럴 필요는 없습니다. 우리는 컴퓨터에 직접 명령하는 게 아니라, 명령을 적으면 컴파일러가 적절히 최적화 하기 때문이죠.

마지막을 보면 << 연산을 하면 64가 -128이 됩니다. 변수의 크기, 부호의 여부에 따라 음수가 나옵니다. 예상하던 결과와는 다른 값이 나옵니다. 그런데 곱셈 연산도 마찬가지입니다. 컴파일러는 부호가 있는(signed) 변수인 것을 알고 있지만 똑같이 -128이 되죠.

-128을 << 연산을 하면 어떻게 될까요? 비트로 보자면 1 0000 0000입니다. 하지만 8 bits만 할당 된 변수에서는 가장 앞의 1은 버려지고 결과는 0000 0000(0)이 됩니다. 곱셈 연산을 하더라도, 컴파일러는 char 자료형이 8 bits 변수인 것을 알지만 같은 결과가 나타납니다. 똑같이 예상하던 결과와 달른 값이 나오죠.

결국 컴파일러는 같은 연산으로 처리한다는 것을 어림잡아 볼 수 있을 것 같습니다.

3장에서 나누기 연산에 사용되는 두 변수가 모두 정수형이면 정수형으로 결과가 나온다고 했던 것 혹시 기억하시나요?

오른쪽 시프트 연산의 결과는 정수형의 나눗셈 연산과 결과가 같습니다.

변수 0101 0101(85)가 있습니다.

Rsh 1 회 : 0010 1010(42)
Rsh 2 회 : 0001 0101(21)
Rsh 4 회 : 0000 0101(5)
Rsh 6 회 : 0000 0001(1)

오른쪽 시프트를 할 때, 가장 왼쪽의 bit가 다음 bit에 복제됩니다. 그래서 부호를 나타내는 bit는 유지됩니다. 그렇기 때문에 음수에서도 나눗셈의 결과를 볼 수 있습니다.
하지만 음수에 대해서는 시프트 연산과 나눗셈이 다릅니다. 비트연산은 소숫점 자리를 버린다고 했죠? -12.1보다 작은 가장 큰 자연수는 -13입니다. 일반적으로 생각하는 버림과는 조금 다르죠.

음수인 1010 1010(-86)으로 비교해볼까요?

비트 연산에서는 소수점 자리를 버립니다. 음수가 더 작은 수가 맞기 때문에 단순한 시프트 연산에서는 맞는 결과이죠. 정수의 나눗셈 연산에서는 사람에게 자연스럽게 소숫점 자리를 버립니다.

1111 1111 에 >> 연산을 아무리 반복해도 -1입니다. 왜냐하면 -1을 2로 나누면 -0.5인데, 이걸 내림연산 하면 -1이 되기 때문입니다.

정수의 나눗셈에서는 -1을 2로 나누면 -0.5이고, 소수점 자리를 버리면 -0 = 0 이 되는 것입니다.

왼쪽 시프트를 얘기하면서 곱셈 대신 시프트를 사용하면 더 빠르다고 말했습니다. 하지만 컴파일러가 최적화를 하기 때문에 시프트 연산을 사용할 필요는 없다고 했죠.
그런데 최적화의 문제만이 아니라 연산의 결과가 달라질 수도 있습니다. 그러니 오류를 무릅쓰고 시프트 연산을 사용할 필요는 없다는 결론을 내릴 수 있습니다.

연산자 순서

산술 연산과 비트 연산들을 소개하면서 연산 순서에 관한 얘기를 몇 번 했습니다.

일단 순서와 관련한 표를 볼까요?

출처 : cppreference.com

너무 많죠? 너무 많아요... 하지만 뒤쪽을 배우다 보면 금방 외웁니다. 아니, 외울 필요도 없습니다. 너무 당연한 순서이기 때문이죠.

예시를 하나 볼까요?

#include <stdio.h>
void main(){
    int a = -43, b = ~(6 - 5) - 1 - 3;
}

와우 정말 쓸 데 없는 프로그램입니다.

가 아니고...

int a = -43, b = ~(6 - 5) - 1 - 3;안에 있는 연산자들을 위 표에서 찾아보세요.
Functional Forms (), 대입연산자 =, 단항연산자 -, 콤마 , , 비트 연산 ~, 산술 연산자 -까지 보입니다.
이 연산자들이 어떤 의미일지 한 번 보세요. 그리고 순서를 한 번 보세요. 꽤나 상식적인 부분이 많습니다.

이 중에 첫번째인 것은 ()입니다. 순서에 따라 연산하면 int a = -43, b = ~1 - 1 - 3; 이 되겠네요.

두번째 연산자는 단항 연산자 -와 ~입니다. 그러면 int a = -43, b = -2 - 1 - 3; 가 됩니다. 단항 연산자는 딱히 표시할 방법이 없습니다. 0010 1011이 1101 0101되었다고 보면 될 것 같습니다.

세번째 연산자는 산술 연산자 -입니다. 그런데 -는 연산자 내에서도 순서가 있죠. 처음에는 int a = -43, b = - 3 - 3; 이 되고, int a = -43, b = - 6; 이 됩니다.

네번째 연산자는 =입니다. 각각의 값을 a와 b에 대입합니다. ,의 순위가 가장 낮기 때문에 a와 b를 한 줄에서 선언해도 서로 영향을 주지 않습니다. 또한 ,는 왼쪽 부터 연산을 하기 때문에 a에 먼저 -43을 대입하고 b에 -6을 대입합니다.

요약

• AND, OR, XOR ,NOT연산을 이해할 수 있다.
• <<연산과 >>연산을 이해할 수 있다.
• 곱셈과 나눗셈, 시프트 연산의 차이를 알 수 있다.
• 연산의 순서를 이해하고 외울 수 있다.

Computer의 의미는 연산 장치입니다.
그러면 이제 본격적으로 연산을 시켜봐야겠죠?

산술연산자 + - * / % =

사칙연산

기본적으로 C언어는 덧셈 뺄셈 곱셈 나눗셈을 모두 사용할 수 있습니다.
덧셈과 뺄셈은 +, -기호를 사용하면 됩니다.
곱셈과 나눗셈은 키보드에 기호가 없기 때문에 조금 다릅니다. 곱셈은 *, 나눗셈은 / 기호를 사용합니다.

#include <stdio.h>
int main(void){
    printf("20 X 30 = %d\n", 20*30);
    return 0;
}

와 같은 방식으로 사용이 가능합니다. 콘솔에서는 20 X 30 = 600으로 보이겠죠.

앞서 배운 scanf를 활용하면

#include <stdio.h>
int main(void){
    int a, b;
    printf("숫자 입력 : ");
    scanf("%d %d", &a, &b);
    printf("20 X 30 = %d\n", a*b);
    return 0;
}

도 가능합니다. 그런데 나눗셈에서는 주의해야 할 게 있습니다.

#include <stdio.h>
int main(void){
    int a = 10, b = 3;
    printf("%d", a/b);
    return 0;
}

이런 프로그램이 있습니다. 10 / 3의 연산 결과를 출력하는 프로그램이죠.
수학에서 10 / 3 = 3.3333...입니다. 그런데 컴퓨터 언어는 다릅니다.
초등학교 때 배웠던 수학 기억하시나요? 10 을 3으로 나누면 몫은 3이었죠. C언어는 정수와 정수로 나눗셈을 하면 몫도 정수가 됩니다.

printf("%f", a/b);를 사용하면 괜찮지 않을까요? 안타깝게도 그렇지 않습니다.
두 변수가 정수일 경우 컴파일러는 정수연산을 합니다. 그러면 결과값도 정수이기 때문에 %f를 사용하면 결과만 이상해집니다.
그렇기 때문에 나눗셈 결과에 소수점이 필요하다면 변수를 선언할 때부터 실수형으로 선언해야 합니다.

다행히도 두 변수 중 하나라도 실수형 변수라면 컴파일러는 다른 변수도 실수형으로 변환해서 연산할 수 있습니다.

#include <stdio.h>
int main(void){
    float a = 10;
    int b = 3;
    printf("%f", a/b);
    return 0;
}

이 프로그램을 실행하면 b는 정수형으로 선언했음에도 불구하고 제대로 된 결과값이 출력됩니다.

%와 =연산

%는 나머지 연산입니다.
나머지 연산이 없다면, 나눗셈을 하고 나누는 수와 몫을 곱해서 원래의 수에서 빼야 합니다.
하지만 나머지 연산으로 표현이 간단해졌죠. printf("10 나누기 3 의 나머지 = %d\n", a%b); 처럼 사용할 수 있습니다. 결과는 10 나누기 3의 나머지 = 1이 됩니다

=은 대입 연산입니다.
수학에서는 등호라고 하지만 컴퓨터언어에서는 대입 연산이라고 불립니다. 그 이유는 연산 순서와 방향이 정해져 있기 때문이죠.
대입 연산은 오른쪽의 값을 왼쪽으로 대입하는 연산입니다. 우리는 변수를 선언할 때 a=10;과 같이 사용합니다.
하지만 10=a;라고는 사용할 수 없습니다. 오른쪽의 값을 왼쪽으로 대입하는 연산이기 때문에 10이라는 정수에 a의 값을 대입할 수 없기 때문이죠.

좀 깊게 들어가볼까요?

#include <stdio.h>
int main(void){
    int a= 20, b = 10;
    a = b = 5;
    printf("%d, %d",a, b);
    return 0;
}

이렇게 하면 어떻게 출력될까요?
처음에 a는 20, b는 10입니다.
그런데 다음 줄에서... 갑자기 멍해집니다. 이런 부분 때문에 연산의 순서를 알아둘 필요가 있습니다.

뒤쪽에서 배우겠지만 대입 연산은 오른쪽 부터 연산합니다.
대입 연산이 오른쪽의 값을 왼쪽으로 대입하는 연산이라고 했죠? 그렇기 때문에 a에 b의 값을 대입해야 합니다. 그 전에, 대입 연산은 오른쪽 부터 연산하기 때문에 b = 5연산을 먼저 하는것이죠. 그러므로 b는 5입니다.
콘솔 출력은 5, 5가 되겠죠.

대입 연산의 특성을 사용한 방법이 하나 더 있습니다. a = a + 5;와 같은 연산이죠. 수학에서는 말도 안되는 식입니다.
하지만 대입 연산에서는 가능합니다. 대입 연산은 오른쪽의 값을 왼쪽에 대입합니다. 그러면 오른쪽의 값을 먼저 알아야겠죠. 오른쪽의 값은 a + 5입니다. 그러니까 원래의 a 값에 5를 더한 값을 a에 대입하는 거죠. 이 연산을 계속 반복하면 a에 5를 더하는 연산을 계속 반복하는 겁니다.

복합대입연산자(Compound Assignment operator)와 증감연산자

이 두 가지 연산은 산술연산을 더 간단히 표현하는 방법입니다.
우선 복합 대입연산자는 대입할 변수에 어떤 연산을 수행해서 그 결과를 대입하는 연산을 간단히 표현하는 겁니다.
바로 위에서 배웠던 a = a + 5;가 그 예가 될 수 있겠죠. 이걸 줄여서 a += 5; 로 표현할 수도 있습니다.
덧셈 뿐 아니라 뺄셈, 곱셈, 나눗셈, 나머지 연산에도 사용할 수 있습니다. +=, -+, *=, /+, %=이렇게요. 뒤에서 배우게 될 비트연산자나 시프트 연산에도 사용할 수 있습니다!

a &= b;
a |= b;
a ^= b;
a <<= b;
a >>= b;

증감연산자는 변수에 1을 더하고 빼는 연산자입니다. a++; 같은 식으로 쓰는 연산자입니다. 이 연산을 하면 a에 1이 더해지죠.
이 연산자는 덧셈과 뺄셈 밖에 없습니다. 1을 곱하거나 나누는 것은 의미가 없으니까요.

증가 연산에도 두 가지 표현이 있습니다. a++;뿐 아니라++a;로도 쓸 수 있거든요. 이번엔 딱 봐도 알겠죠? 연산 순서에 따라 달라진다는 것을요. ++a는 덧셈 연산을 먼저 하고 다음 연산을 하는 겁니다. a++는 다른 연산을 먼저 하고 덧셈을 합니다.

여기서 다른 연산은 한 문장에서 덧셈 외의 연산같은 것들을 말합니다.
예를 들어 a = 5;인 변수가 있을 때 printf("%d",a++);가 있을 수 있습니다. 이 명령은 5가 출력됩니다. 하지만 printf 연산 후에 a는 6이 되죠.
printf("%d",++a);는 6을 출력합니다. 그리고 출력 이후에도 a 값은 6입니다.

내용이 너무 길기도 하고 연산 치고는 성격이 좀 다른 내용이어서 다음 편에서 이어서 하도록 하겠습니다.
다음 편에서는 비트 연산과 시프트 연산, 그리고 연산 순서에 대해 알아보겠습니다.
연산 순서는 여러가지 연산자들 사이에서 어떤 순서로 처리되는지 알아야 원하는 대로 프로그램이 실행되기 때문에 중요합니다.

요약

• 산술 연산자로 덧셈(+), 뺄셈(-), 곱셈(*), 나눗셈(/)을 할 수 있다.
• 정수 나눗셈과 실수 나눗셈의 차이를 알 수 있다.
• 나머지 연산(%)과 대입 연산(=)을 할 수 있다.
• 대입 연산의 순서를 알 수 있다.
• +=, -= 같은 복합 대입 연산자를 사용할 수 있다.
• a++, ++a같은 증감연산자를 사용할 수 있다.

저수준 언어

언어의 수준(Level)은 상대적이지만 요즘은 코볼이나 어셈블리를 배우지 않는 점에서 C언어는 Low-Level 언어에 해당합니다. 코볼이나 어셈블리는 C언어에 대해 상대적으로 더 낮은 수준인 언어입니다.

Level이 낮으면 하드웨어에 직접 엑세스하기 쉬워집니다. 그만큼 처리가 빨리지죠. 반면에 Level이 높아지면 복잡한 구조를 단순하게 만들 수 있다는 점에서 코딩이 편해집니다. 속도는 느려지지만 쉬운 코딩으로 버그가 줄어들고, 복잡한 프로그램을 만들 수 있습니다.
가장 낮은 수준인 어셈블리어는 CPU의 명령어에 맞게 직접 코딩을 해야 합니다. 그러다보니 코딩을 하기 위해선 컴퓨터 구조에 대한 학습은 필수였습니다. 컴퓨터 구조에 맞게 명령을 입력해야 했거든요. 보다 높은 수준인 C언어는 덧셈, 비교, 변수 지정 등을 한 줄로 끝낼 수 있게 되었습니다. 대학교에선 여전히 컴퓨터 구조를 학습하긴 하지만 컴퓨터 언어를 사용하는 데에는 중요하지 않게 되었습니다. 그래서 어셈블리어에 대해 상대적으로 고급 언어입니다.

객체지향 언어는 당연히 객체 개념을 통해 C언어에 비해 고급 언어로 칭해집니다. 객체지향 언어는 메모리에 대한 고려를 거의 하지 않습니다. 그래서 String 형의 변수를 다른 변수에 저장할 때에도 대입 연산을 이용할 수 있습니다. 무엇보다 객체 지향 언어는 객체를 이용하는게 특징입니다. 프로그램 실행에 Stack구조(객체를 계속 쌓는 방식)를 사용하기 때문에 이 전의 코드를 조금 바꾸어 재사용하거나 프로그램 최적화 및 관리가 쉽습니다.
그래서 고급 언어로 사용자와 상호작용을 하기 위한 Front End를 담당하고 저급 언어로 내부의 처리를 담당하기도 합니다. 자바나 코틀린을 사용하는 것으로 잘 알려진 안드로이드도 중요한 시스템 부분은 C언어로 만든 바이너리입니다.

C언어에서 사용하는 scanf는 키보드 입력을 받는 함수인데, 실제 사용자의 입력을 받기 쉽지 않습니다. scanf는 2바이트 문자인 한글을 입력받기 쉽지 않습니다. 또한 키보드로 입력되는 데이터를 버퍼에 저장하는데, 그 버퍼를 자주 비워줘야 프로그램이 의도한 대로 동작합니다. 또한 보안 문제로 대체 함수가 도입되어 있습니다. printf_s, scanf_s이죠. 대부분 보안 프로그램이 scanf를 사용한 경우 프로그램 실행을 차단합니다.

위와 같은 특성으로 인해 printf나 scanf를 사용자의 입력을 받는 용도로 사용하지 않습니다. 다만 C언어 개발을 배우는 과정에서 콘솔로 입/출력을 받을 때는 가장 자주 사용되는 함수입니다. 실제 프로그램 개발에서는 printf_s를 사용해야 하고, 일반적으로는 객체지향 언어로 프로그래밍 합니다.

예제

보통 C언어 프로그램은 Console(콘솔)로 실행됩니다. Console에서 사용자의 입력 및 출력을 담당하는 함수가 printf, scanf입니다.

int main(void)    //진입함수 main()
{
    int a;    //정수변수 선언
    printf("숫자 입력 : ");
    scanf("%d",&a);    //키보드로부터 값을 입력받아 변수에 저장
    printf("덧셈 결과 %d \n",a+3);     //%d의 숫자와 대응되는 값의 수는 일치
}

printf함수를 통해 숫자 입력 :를 콘솔 화면에 출력합니다. 줄 내림을 하지 않았기 때문에 콘솔의 커서는 줄 내림을 하지 않고 콜론 오른쪽에 있습니다.

숫자를 입력하고 엔터를 누르면 scanf가 입력 값을 받아서 a에 저장합니다. 큰 따옴표 안에 %d가 있고, 큰 따옴표 뒤에 반점으로 구분하여 변수 이름이 적혀 있습니다.

printf함수를 다시 호출합니다. 큰 따옴표 안에 %d와 \n이 있지만 콘솔에는 보이지 않습니다. 왜 그런지 아래에서 알아보겠습니다.

printf

printf는 단순히 문장만 출력하지 않습니다. 변수를 출력할 수도 있지요. 그래서 같은 문장이라도 변수에 따라 출력이 달라지게 됩니다.
출력할 문장에 변수를 포함하는 방법이 %d를 사용하는 방법입니다. 그리고 그 뒤에 파라미터를 추가하여 %d에 대응하는 값을 출력하는 겁니다.

%d decimal(10진수)
%x hexadecimal(16진수)
%o octal number(8진수)
%e exponentiation(지수형)
%u unsigned(부호가 없는 자료형)
%f float(실수형)
%p pointer(포인터)
%c char(문자형)
%s string(문자열)

변수 여러개 출력하기

printf는 변수를 여러개 출력할 수 있습니다.

printf("아스키코드 %d은 %c입니다.", 97, 97);

%d와 %c를 두개 넣었습니다. 그리고 파라미터로 두개를 전달했습니다.
그랬더니 아스키코드 97은 a 입니다. 라고 출력됩니다.

2장 자료형에서 살짝 언급했는데, 같은 97을 전달받고도 정수형으로 표현한 것과 문자형을로 표현한 것이 다릅니다.

변수의 자릿수 정렬하기

printf는 자릿수를 정할 수 있습니다.
아래와 같이 입력하면

printf("%d \n",192);
printf("%d",6);

192
6

위와 같이 출력됩니다. 그런데 아래와 같이 입력하면

printf("%3d\n",192);
printf("%3d",6);

192
  6

위와 같이 출력됩니다. 자료형을 나타내는 문자 앞에 숫자를 붙이면 자릿수를 미리 지정할 수 있습니다.

실수형에서는 좀 더 복잡한 정렬도 가능합니다.

#include<stdio.h>
int main(){
    float a = 3.14159;
    int b = 192;
    printf("%6.3f\n",a);
    printf("%.3f\n",a);
    printf("%6d\n",b);
}

위와 같은 프로그램을 실행하면

  3.142
3.142
   192

와 같은 결과를 얻을 수 있습니다.

실수형은 전체 자릿수와 소숫점 아래 자릿수를 제한할 수 있고, 반올림하여 표현할 수 있습니다. 또한, 전체 자릿수는 지정하지 않고 소숫점 아래 자릿수만 제한할 수도 있습니다.

정수형과 실수형을 모두 6자리로 제한하니 출력에서는 마지막 숫자가 같은 위치에 있는 것을 알 수 있습니다.

printf는 줄 내림을 위해 특별한 표현을 사용합니다.

printf는 한 줄로 명령이 이루어집니다. 게다가 컴파일러는 줄 내림을 무시합니다. 그렇다면 줄 내림을 출력하는 방법은 무엇일까요?

바로 *이스케이프 시퀸스(Escape sequence) *라는 것을 사용하면 됩니다!. 문자열을 입력하고 있는데 \를 통해 escape해서 컴파일러의 처리를 한다고 보면 될 것 같습니다.

printf("줄 내림\n테스트");

라고 입력하면

줄 내림
테스트

라고 뜨게 됩니다.

그 외에도

\t 탭
\r 엔터(carriage return)
\v 수직 탭(vertical tab)
\b 지우기(backspace)
\f 폼 피드, 페이지 피드
\a 경고(beep음 경고)

가 있습니다. 대부분은 직접 입력이 가능하지만 알아두면 좋습니다.

그렇다면 컴파일러가 인식하고 콘솔에 출력하지 않는 문자를 콘솔에 출력하고 싶으면 어떻게 해야 할까요? 큰 따옴표는 문자열을 의미하는 것이어서 큰 따옴표를 입력하면 문자열이 끝나버리고 말죠. %도 %d, %f를 위해 할당된 문자여서 출력이 안됩니다. 도 마찬가지죠.
이러한 문자를 출력하는 것도 Escape Sequence 입니다.

\\
\"
\?
%%

와 같은 방법이죠. 음... Escape Sequence로부터 한번 더 Escape한다는 느낌입니다.

printf("\"큰 따옴표\" \\n %%d");

라고 입력하면

"큰 따옴표" \n %d

라고 출력됩니다.

scanf

scanf의 기본적인 사용법은 같습니다. printf와 다른 부분은 변수를 작성하는 뒤의 변수 이름 부분에 a가 아닌 &a를 사용한다는 것입니다.
추후 포인터를 학습하면서 자세히 다룰 부분인데, 변수의 메모리 주소를 의미합니다. scanf는 입력받은 데이터를 변수에 저장하는 것이 아니라 변수가 저장된 메모리 주소에 저장하기 때문에 &a를 사용합니다.

복습

#include<stdio.h>
int main()
{
    int salary;//월급
    int deposit ;//저금액

    printf("월급을 입력하시오: ");
    scanf("$d",&salary);

    deposit = 10 * 12 * salary;

    printf("10년간 저축액: %d \n", deposit);
    return 0;
}

#include<stdio.h>
int main()

    float radius;
    float area;

    printf("반지름을 입력하십시오: ");
    scanf("%f", %radius);

    area = 3.14 * radius * radius;

    printf("원의 면적: %f\n", area);
    return 0;
}

#include<stdio.h>
int main(){
    int id, pass;
    //ID와 PW자리에 '_'가 4개가 있고, ID 또는 PW를 입력하면 '\'가 없어지는 프로그램

    printf("ID와 PW를 4개의 숫자로 입력하세요:\n");
    printf("id:____\b\b\b\b");
    scanf("%d", &id);
    printf("pass:____\b\b\b\b");
    scanf("%d", &pass);
    printf("\a입력된 아이디는 \"%d\"이고 패스워드는 \"%d\"입니다.\n", id, pass);
    return 0;
}

요약

• 출력을 위해 printf를 사용할 수 있다. 변수를 출력할 수도 있다.
• 입력을 받기 위해 scanf를 사용할 수 있다.
• printf나 scanf에 변수를 포함하도록 할 수 있다.
• escape squence를 사용하여 원하는 문자열을 출력할 수 있다.

C언어에서는 변수를 저장하는데 그 변수의 형식을 지정해줘야 합니다.

서로 다른 형식끼리 구분해주기도 하고, 이 값을 어떻게 저장해야 할지 컴파일러에게 알려주기도 합니다.

#include <stdio.h>
int main() {
  int a;
  a = 10;
  printf("a 의 값은 : %d", a);
  return 0;
}

a라는 이름의 변수를 선언했습니다. 자료형은 int입니다.

printf 함수를 호출합니다. a의 값은 : 1이라는 결과를 얻을 수 있습니다. %d가 왜 10으로 바뀌는지는 다음 장에서 배울겁니다.

자료형 종류

대부분 언어에서 자료형은 같습니다. 심지어는 데이터베이스에서도 비슷한 표현을 사용하죠.

자료형은 크게 세 가지로 구분됩니다. 문자형, 정수형, 실수형이 있습니다.
각 자료형별로 메모리를 사용하는 크기에 따라 자료형이 여러가지로 나뉩니다. 또한 부호의 유무로 자료형의 범위가 결정됩니다. 항상 양수인 자료형을 unsigned, 부호가 있어야 하는 자료를 signed로 선언합니다. 기본값은 signed입니다.

컴퓨터에서 저장하는 방식에 대하여

1bit는 0과 1을 저장할 수 있는 이진수 입니다. 1byte는 8bits입니다. 그래서 1byte는
2⁸(256)개의 숫자를 구분할 수 있습니다.

출처 : cplusplus.com

문자형

문자형은 문자 한개를 저장합니다.

char a;와 같은 식으로 선언합니다. char은 character라는 뜻을 갖고 있습니다. char는 1바이트입니다.
한글은 2바이트 문자이기 때문에 한글을 다룰 땐 조심해야 합니다. 나중에 배열과 함께 배웁니다.

1바이트이므로 256개의 숫자를 구분할 수 있습니다. unsigned char는 부호가 없는 숫자로 0 ~ 255까지 저장할 수 있습니다. signed char는 부호가 있는 숫자로 -128 ~ 127까지 저장할 수 있습니다.

참고로, 문자형도 정수를 저장합니다. 숫자를 읽어와서 문자에 대응해서 표시하는겁니다.
따라서 문자형은 메모리 크기가 다른 정수형이라고 생각하셔도 됩니다.
정수형은 가장 작은 자료형이 4byte를 차지하기 때문에, 작은 숫자를 저장할 때는 char를 사용하기도 합니다.

정수형

정수형은 정수를 저장합니다.

4바이트를 저장하는 int가 기본형입니다. int는 integer라는 뜻입니다.

1바이트를 저장하는 char, 8바이트를 저장하는 long int, 16바이트를 저장할 수 있는 long long int가 있습니다.

4바이트인 int는 4,294,967,296개의 숫자를 구분할 수 있습니다. unsigned int는 0 ~ 4,294,967,295, signed int는 -2147483648 ~ 21473647까지 저장할 수 있습니다.

실수형

실수형은 실수를 저장합니다.

정수형이나 문자형과는 좀 다른 형태로 저장합니다.
실수형은 숫자와 소숫점의 위치를 저장합니다.

1.7 X 10^-3

와 같은 형태로 저장합니다. 10은 제외하고, 1.7과 ^-3만 저장하는 형태죠. 여기서 숫자 1.7에는 굳이 소수점 자릿수까지 저장할 필요는 없겠죠?
그래서 실수형은 메모리의 크기와 숫자의 크기가 비례하지 않습니다. 숫자의 크기는 윗첨자에 영향을 받는건데, 가장 큰 메모리를 차지하는 부분은 앞에 있는 숫자 부분이기 때문이죠. 이걸 위의 표에서는 '정확도'라고 표현했습니다. 앞의 숫자가 길어질수록 반올림하거나 버림하는 단위가 작아진다는 의미니까요.

char과 ASCII 코드

신기한 것은 char형은 문자도 저장하고, 정수도 저장한다는 것입니다. 내용물에 따라 형식을 구분하는 걸까요? 아닙니다.

사실 C에서는 문자를 숫자로 저장합니다. 정확히는 ASCII(아스키)코드를 사용해서 저장합니다. 아스키 코드 위키에서 변환 표를 확인할 수 있습니다.

그래서 char형 변수를 사용할 때는 숫자형식으로 불러와도 되고, 문자형식으로 불러와도 됩니다. 자료형이 char인 변수에서 97을 문자로 불러오면 a, 숫자로 불러오면 97이 됩니다.
그러므로 프로그램 내부에서는 어떻게 처리하든 상관 없지만 그것을 출력할 때는 문자인지 정수인지 제대로 지정해줘야 Console에 프로그래머가 의도한 대로 표시됩니다.

다음 장에서는 printf와 scanf를 배우게 됩니다. printf와 scanf는 가장 기본적인 입/출력 함수입니다. 이 함수에서 문자와 정수를 구분하는 방법을 자료형과 연관지어 다룰겁니다

복습

#include<stdio.h>

int main()
{
    char ch = 'A'; //변수 선언
    printf("%c의 아스키코드= %d \n", ch, ch);
    ch = ch + 1;
    printf("%c의 아스키코드= %d \n", ch, ch);

    return 0;
}

요약

• 아스키라는 텍스트 인코딩 방법을 알 수 있다.
• 자료형의 종류를 알 수 있다.
• 변수의 사용 목적에 따라 signed와 unsigned를 지정할 수 있다.

대체로 컴퓨터 언어에 대한 강좌라고 하면 이론적인 부분을 먼저 설명하고 그것을 활용한 예시 코드를 보여주게 마련입니다. 물론 종이 교재도 마찬가지구요.

하지만 좀 다른 접근으로 먼저 코드를 보고 나서 그 설명을 읽게 하고 싶었습니다. 개인적 경험으로는 이런 방법이 더 이해하기 쉬웠기 때문입니다.

하지만 설명해야 할 부분 중에서도 기초적인 부분은 먼저 설명해야 코드를 볼때 짐작이라도 가능한 부분이 있으니 이 점 참고해서 너무 난해하다면 아래쪽을 먼저 읽어보길 권합니다.

1장 Hello World!

모든 프로그래밍 언어는 Hello World!로 시작합니다.
단순히 프로그램 실행 결과에 Hello World를 출력하는 프로그램이죠.

#include <stdio.h>

int main(void)
{
    printf("Hello World!");
    return 0;
}

첫 장이기도 하고, 원래 Hello World는 이론 보다는 '실행해보기'에 의미가 있기 때문에 구조만 확인하면 됩니다.

이렇게 끝내기엔 글이 너무 짧아 참고할 만한 내용을 적어봤습니다.

주석(comment)

영어로는 comment. 주석을 사용하면 Compiler는 해당 문장을 인식하지 않습니다.
언어마다 다르지만 보통은 두 가지 형식을 사용합니다.

C, JAVA 등의 계열은 // comment으로 한 줄을 주석처리하고, /* comment */로 여러 줄을 주석처리 할 수 있습니다.
HTML이나 CSS등의 언어는 <!-- comment -->로 주석처리 할 수 있습니다.
터미널 셸에서는 # comment
php에서는 ; comment 로 주석처리 할 수 있습니다.

#include

#include 를 통해서 다른 코드를 참조할 수 있습니다. 위의 파일만으로는 'Hello World'를 출력할 수 없습니다. 컴퓨터는 printf가 뭔지 모르기 때문이죠. 하지만 #include 를 통해 stdio.h 파일을 참조하도록 하면 'Hello World'를 출력할 수 있습니다

개발자가 stdio.h파일을 만들지 않았지만, C언어를 위한 IDE(컴파일러만 따로 설치해도 됨)를 설치하면서 함께 제공됩니다. < > 안에 있는 파일(소스)은 컴파일러가 지정한 디렉터리에서 찾습니다. 그리고 이 디렉터리에는 stdio.h 뿐 아니라 여러가지 미리 정의된 파일들이 있습니다. 그렇기 때문에 개발자는 stdio.h 파일의 위치를 몰라도 사용할 수 있습니다.

그렇다면 개발자가 미리 정의한 파일들은 어떻게 불러와야 할까요?
그럴 때는 꺾쇠 괄호 대신 쌍따옴표를 사용합니다. #include "mycode.h" 처럼 사용하면 됩니다.
그러면 컴파일러는 원래 파일과 같은 디렉터리에서 mycode.h 파일을 찾아 참조합니다.
가장 메인이 되는 파일이 너무 복잡하다면 다른 소스에 코드를 작성하고 불러오기만 하면 되죠.

stdio는 STandarD Input/Output의 뜻을 가지고 있습니다.
아래에 사용하는 printf 도 stdio.h 를 참조했기 때문에 사용할 수 있는 것입니다.

int main(void)

int는 return(반환) Type(형식)을 말합니다. 이런 종류는 void, int, char, long, string 등이 있는데, 이를 자료형 이라고 합니다. C언어에서는 배우지 않지만 추후 객체지향(Object Oriented) 언어를 사용하면 무엇이든 반환할 수 있게 됩니다!.
C언어는 객체(Object)라는 개념이 없습니다. 비슷한 개념으로 구조체(Structure)가 있는데, C언어는 구조체 자체를 반환할 수는 없고, 포인터(Pointer)를 이용하는 방법이 있습니다. 함수(Function) 안에서 사용했던 구조체의 주소를 저장하는 포인터를 반환하면, 반환을 받은 함수에서 사용할 수 있습니다.

main 은 함수 이름입니다. C언어는 처음 실행할 때 무조건 main 함수가 실행됩니다. 이름은 숫자로 시작할 수 없습니다.
main 함수는 int 를 반환하도록 하는 것이 좋습니다. 윈도용 C컴파일러의 경우 void main{}을 허용하지만, 리눅스나 유닉스 계열에서는 반드시 int형을 반환해야 합니다.

(void) 는 함수에 전달하는 인자(Parameter, Argument)를 정합니다. 파라미터가 있을 경우, myfunction(int i, char s) 와 같이 변수의 형식과 변수의 이름을 지정하여 전달합니다. 변수가 여러 개이면 반점(,)으로 구분하여 추가할 수 있습니다. void 대신 빈 칸이어도 됩니다.
여기서 인자로 전달되는 변수는 지역변수(Local Variable)입니다. 이 함수 안에서만 사용되는 변수라는 뜻입니다. 함수 밖에서는 영향을 주지 않는다는 의미로, 다른 함수에서 파라미터로 전달하는 변수가 논리적으로는 같은 변수라 하더라도 이름이 달라도 됩니다.
아래 예시를 봅시다.

void print(int id); //main함수에서 print함수를 사용하기 전에 print함수가 존재한다는 것을 미리 선언.

void main(){
    int name = 15; //name 변수가 15를 갖고 있다.
    print(name); //print를 호출하면서 name이 갖고 있는 15를 전달한다.
}
void print(int id){ //15를 받아서 지역변수 id로 저장한다.
    printf("%d",id); //15를 출력한다.
}

{}

앞으로 가장 자주 사용할 것이고, 제일 신경써야 하는 부분입니다.

코드를 한 묶음으로 정해주는 역할입니다. 중괄호 사이의 세 줄은 int main(void) 함수에 포함된 코드라는 의미입니다.

여러 줄을 포함하기 때문에 중괄호가 열리는지, 닫히는지 파악하기 어렵습니다.
혹시나 다른 위치에서 중괄호를 닫으면 정상적으로 실행은 되지만 개발자가 원하던 출력이 나오지 않을 수도 있습니다.

void main(){
    int i =1, j = 1;
    if(i == 1){ // i 가 1이라면 수행한다.
        if(j == 2){ // j가 2이라면 수행한다.
        //지금은 if문이 충족되지 않으므로 이 부분은 무시한다.
        }
        printf("j=2");
    }
}

이런 코드를 봅시다. 이런 코드는 분명 정상적으로 작동할겁니다.
하지만 printf("j=2");는 if(j == 2) 구문 밖에 있습니다. 원래는 j가 2인지 확인하고 j=2를 출력했어야 합니다. 하지만 그것과 상관 없이 j=2를 출력하게 됩니다.

printf("Hello World!");

stdio.h에 포함된 함수인 printf로 'Hello World!'를 출력하는 함수입니다.
printf()함수에 'Hello World!'를 파라미터로 전달했고, printf 함수가 실행되면서 인자를 출력하게 됩니다.

큰 따옴표를 사용하면 그 안의 내용은 char형 배열(array)을 의미합니다. 객체지향 언어에서는 char형 배열을 String이란 객체로 구현해뒀습니다. 나중에 객체지향 언어를 학습할 때 char배열과 String에 어떤 차이가 있는지 확인해보면 객체지향을 이해하는데 조금이나마 도움이 될 겁니다.

;

;(세미콜론)은 명령 한 줄이 끝남을 의미합니다.
C언어를 포함하여 세미콜론으로 명령을 구분하는 언어들은 컴파일러가 줄 내림을 인식하지 않습니다. 띄어쓰기도 한칸만 인식합니다.

#include <stdio.h>
int main(void){printf("Hello World!");return 0;}

그렇기 때문에 위와 같이 코드를 작성해도 결과는 같습니다. 다만, 주석이 있는 부분은 컴파일러가 무시하기 때문에 반드시 줄 내림을 해야 합니다.

return 0;

함수 실행 결과를 리턴하고 함수를 종료합니다. return 을 하고 나면 그 함수는 완전히 종료됩니다. 그러므로 return 이후의 명령은 모두 무시됩니다.
리턴값이 없는 void형식의 함수라도 return ;를 하면 함수가 종료됩니다.
if문으로 분기하면서 함수를 종료할 필요가 있다면 return으로 종료할 수 있습니다.

리턴 값은 처음 함수를 선언할 때 지정했던 형으로만 반환할 수 있습니다. 함수를 int로 선언했기 때문에 int형 값(value)인 0을 반환했습니다.

다 섞어서 응용하기

#include <stdio.h>
void main(){    //1+1 계산하기!
    int sum = calc(1,1);
    printf(%d, sum);
    //return;
}
int calc(int i, int j){
    return i+j;
}

이제 이 정도는 이해할 수 있겠죠? 갑자기 진도를 너무 많이 나갔나요?ㅎ...

main 함수가 실행이 되고, //1+1 계산하기! 는 무시됩니다.
int 형 변수인 sum을 선언합니다. sum은 calc 함수를 실행한 결과를 저장합니다.
calc 함수는 파라미터로 1 두개를 받습니다. 큰 따옴표가 없기 때문에 int 형입니다. String은 큰 따옴표로 구분하지만, int 형을 지정하는 표시는 없기 때문에 변수 이름은 숫자로 시작할 수 없습니다.
calc 함수는 두 숫자를 i, j라는 이름으로 전달받습니다. 그리고 두 변수 i와 j를 더한 값을 return을 통해 반환합니다.
결과적으로 sum은 1+1을 연산한 값이 저장됩니다. printf는 digit형식의 문자를 출력합니다. sum이 그 digit형식에 해당하는 변수입니다.
main 함수는 반환 형식이 void이기 때문에 return문이 없어도 종료됩니다. 아무것도 반환하지 않는 return;로도 함수를 종료할 수 있습니다.

요약

• Hello World를 출력할 수 있다.
• #include 로 다른 코드를 참조할 수 있다.
• // 또는 /* */로 주석을 작성할 수 있다.
• {}로 코드를 묶을 수 있다.
• return 을 사용할 수 있다. 함수를 선언할 때 반환되는 종류를 지정해야 한다.
• 함수를 호출할 수 있다. 호출 할 때 소괄호로 파라미터를 전달할 수 있다.