1.타입의 내부

1.정수의 내부

메모리를 구성하는 비트는 0과 1만 저장할 수 있는 기억소자이다. 이 단순한 비트로 큰 수와 정밀한 실수를 어떻게 표현하고 관리하는지 연구해 보자. 실무에 당장 활용되는 지식은 아니지만 타입의 내부 구조를 들여다 보면 프로그래밍 언어의 깊은 곳을 이해할 수 있다.

정수는 비트 여러 개를 모아 0과 1의 조합으로 이진수를 표현한다. 비트 n개가 모이면 2n가지의 수를 표현할 수 있으며 부호없는 정수는 0 ~ 2n-1의 범위를 저장한다. 부호가 있으면 음수를 표현할 수 있지만 최대 표현수는 절반이 된다. 16비트의 unsigned short형은 216-1(65535)까지 표현할 수 있고 32비트의 unsigned int형은 232-1(4294967295)의 큰 값을 표현할 수 있다.

변수가 기억할 수 있는 최대 표현 범위를 넘어서는 현상을 오버플로우(Overflow)라고 하며 변수는 초과된 값을 기억하지 못하고 엉뚱한 값을 가진다.

 

IncOverflow

#include <stdio.h>

 

int main()

{

     unsigned short us = 65535;

     printf("us = %d\n", us);

     us++;

     printf("us = %d\n", us);

}

실행결과

us=65535

us=0

 

16비트 크기의 us변수를 이 타입에 저장할 수 있는 최대값 65535로 초기화했다. 이 상태에서 1증가시키면 65536이 되는데 이 값은 16비트의 최대 표현 범위를 초과하여 오버플로우된다. us 변수가 65536을 제대로 기억하지 못하고 0이 되는 현상을 비트의 세계에서 살펴보자.

65535는 이진수로 1이 16개인데 여기에 1 더하면 자리 넘침이 발생하여 1 다음에 0이 16개인 17자리의 이진수가 된다. 최상위 비트의 1은 16비트 범위 바깥이어서 잘려 나가고 남은 비트는 모두 0이므로 결국 65536은 0과 같다. 8비트 범위에서 256(28)이나 32비트 범위에서 4294967296(232)도 결국 0이다. 반대로 최소값보다 더 작아지면 최대값이 된다. 16비트 정수 0을 1감소시키면 65535이다.

비트의 한계로 인해 컴퓨터의 정수는 수학의 정수와 다르다. 수학의 정수는 음양으로 무한대의 범위를 표현하지만 디지털 세계의 정수는 할당된 비트수에 따라 표현 범위의 제한이 있다. 그래서 표현하할 값의 범위에 따라 타입을 잘 선택해야 하는데 실생활에서 수십억 이상의 수가 필요한 경우는 드물어 int형이면 무난하다.

2.음수의 표현

다음은 부호 있는 정수 타입을 연구해 보자. 0과 1만 나열되는 비트의 세계에서 수를 해석하는 방법은 일종의 약속이다. 부호없는 정수는 모든 비트를 수로만 인식한다. 2진수의 각 자리수는 2의 거듭승에 해당하는 가중치를 가지는데 10진수의 각 자리수가 일, 십, 백, 천 등 10의 거듭승으로 평가되는 것과 같다. 이진수 101은 각 자리수의 가중치를 곱해 더하면 십진수 5가 된다.

 

101 = 1*22 + 0*21 + 1*20 = 4 + 0 + 1 = 5

 

이 약속을 변경하여 일관된 규칙을 정의하면 여러 가지 방식으로 음수를 표현할 수 있다. 다음은 3비트의 정수로 음수를 표현하는 다양한 약속의 예이다.

 

이진수

부호 없음

일정 수 감소

부호 비트와 절대값

1의 보수

2의 보수

000

0

-4

0

0

0

001

1

-3

1

1

1

010

2

-2

2

2

2

011

3

-1

3

3

3

100

4

0

-0

-3

-4

101

5

1

-1

-2

-3

110

6

2

-2

-1

-2

111

7

3

-3

-0

-1

 

■ 일정수 감소법 : 부호없는 값에서 일정한 수를 빼 평행이동하여 음수를 표현한다. 이때 빼는 값을 바이어스(bias)라고 하는데 전체 범위의 절반을 빼면 음양의 범위가 비슷해진다. 3비트는 4를 바이어스로 사용하여 원래 0이 -4가 되고 4는 0이 되며 7은 3이 되어 -4 ~ 3까지 표현할 수 있다. 단순하지만 비트열과 숫자의 대응 관계가 직관적이지 못하다.

■ 부호 비트와 절대값 : 최상위 1비트를 부호로 사용하고 남은 2비트로 절대값을 표현한다. 표현 가능한 절대값은 절반으로 줄어들지만 음수를 표현할 수 있어 가지수는 비슷하다. 이 방법은 부호에 따라 0이 100과 000으로 두 개 존재하여 모호하다는 단점이 있다.

■ 1의 보수법 : 양수 비트를 반전하여 음수를 만든다. 양수 2(010)의 비트를 반전한 101을 -2로 표현한다. 연산은 간단하지만 앞의 방법과 마찬가지로 +0, -0이 따로 존재한다.

■ 2의 보수법 : 1의 보수에 1을 더해 음수를 표현한다. 즉 모든 비트를 반전시킨 후 1을 더하는 방식인데 2(010)를 모두 반전시키면 101이 되고 여기에 1을 더한 110을 -2로 표현한다. -0은 1000이 되어 오버플로우되므로 한가지의 0만 존재한다.

 

이 외에도 여러 가지 방법을 생각할 수 있는데 현대의 컴퓨터는 모두 2의 보수법을 사용한다. 반전 후 1을 더하는 것이 번잡해 보이지만 기계적인 연산이어서 빠르며 2의 보수를 사용하면 덧셈만으로 뺄셈이 가능해지는 이점이 있다.

8비트의 부호없는 변수가 100의 값을 가지고 있을 때 256(0x100)을 더하면 어떻게 되는지 살펴보자. 결과는 356이지만 오버플로우되어 원래값 100이 된다. 100부터 1씩 계속 증가하기를 256번 반복하면 결국 제자리이다. 그래서 8비트에서 256은 0과 같다.

이번에는 100 + 255(0xff)를 계산해 보자. 결과값인 355도 오버플로우되어 최상위 비트의 256(0x100)이 잘려 나가고 99만 남는다. 255는 -1인데 이 값은 -1에 대한 2의 보수이다. 같은 원리로 254는 -2이고 253은 -3이다. 컴퓨터는 덧셈을 하는 가산기만 있고 감산기는 따로 없어 -n 연산을 할 때 n을 2의 보수로 만든 후 더한다. 다음 예제로 이 동작을 확인해 보자.

 

Complement

#include <stdio.h>

 

int main()

{

     unsigned char a = 99;

     unsigned char b = 77;

 

     b = ~b + 1;

     a = a + b;

     printf("a = %d, b = %d\n", a, b);

}

실행결과

a = 22, b = 179

 

b를 반전시키고 1을 더해 2의 보수로 만들었다. 77(0x4d:01001101)을 반전 후 1 더하면 179(0xb3:10110011)가 된다. 이 값을 a에 더하면 278(0x116:100010110)이 되는데 자리 넘침이 발생하여 256은 날라가고 22(0x16:00010110)만 남는다. 결국 a에서 b를 빼는 것과 같다.

보수(Complement)는 어떤 수(기수)가 되기 위해 보충되어야 하는 수인데 기수 10에 대한 3의 보수는 7이다. 2의 보수는 n비트에 대해 2n을 기수로 한 보수이다. 8비트에서 2의 보수는 256이 되기 위해 더 필요한 수이다. a의 2의 보수 b가 있을 때 a + b = 256이며 8비트에서 256은 0과 같다. 그러므로 a + b = 0이고 a = -b, b = -a의 관계가 성립한다.

1의 보수는 2n - 1을 기수로 한 보수이며 n이 8일 때 255(11111111)가 기수이다. 1의 보수끼리는 정확하게 비트 반전 관계가 성립하며 이 값은 기계적으로 아주 쉽게 구할 수 있다. 1의 보수에 대한 기수보다 2의 보수에 대한 기수가 1 더 크므로 반전 후 1을 더하면 2의 보수가 된다.

3.바이트 순서

메모리의 저장 단위는 바이트인데 비해 실제 저장할 값은 32비트나 64비트로 더 길다. 그래서 연속적인 바이트에 값을 나누어 저장하는데 순서에 따라 두 가지 방식이 있다. 0x12345678는 총 32비트이며 0x12, 0x34, 0x56, 0x78의 8비트값 4개로 구성된다. 일련의 4바이트를 다음 두 가지 방법으로 저장할 수 있다.

■ 빅 엔디안(Big Endian:순워드) : 높은 자리수를 먼저 저장한다. 0x12가 가장 앞쪽 바이트에 오고 나머지 바이트가 순서대로 저장된다. 사람이 글을 읽는 순서와 같아 자연스럽고 이해하기 쉽다. 모토롤라 계열의 CPU와 대부분의 RISC CPU, 자바 가상 머신이 이 방식을 사용한다.

■ 리틀 엔디안(Little Endian:역워드) : 낮은 자리수를 먼저 저장한다. 가장 뒤쪽 바이트인 0x78이 제일 앞에 오고 0x12가 제일 뒤에 저장된다. 사람이 보기에 부자연스럽지만 기계가 다루기는 더 효율적이다. 인텔 계열의 CPU와 DEC의 알파 칩이 이 방식을 사용한다.

 

사람의 입장에서는 빅 엔디안이 자연스럽지만 CPU의 입장에서는 리틀 엔디안이 더 다루기 쉽다. 0x1234라는 32비트 정수값에서 하위 2바이트만 읽는다고 해 보자. int형의 값을 short형 변수에 대입하거나 포인터를 통해 간접적으로 읽을 때에 해당한다. 다음 그림은 정수형 포인터 pi가 가리키는 32비트 값을 (short *)로 캐스팅해서 읽는 예이다.

리틀 엔디안은 pi가 가리키는 원래 번지에서 2바이트만 읽는다. 낮은 자리수가 앞쪽에 있기 때문에 위치는 그대로이고 읽는 길이만 바꾸면 된다. 이에 비해 빅 엔디안은 pi가 가리키는 곳에 선행 제로 2바이트가 있어 뒤쪽의 2바이트를 읽으려면 pi를 뒤쪽으로 2바이트 옮겨야 한다.

타입의 확장이 일어날 때도 비슷한데 0x1234라는 16비트 정수를 32비트로 확장해 보자. 이런 경우는 늘상 일어나는데 short형 변수를 인수로 전달할 때, 수식 내에서 연산될 때 항상 32비트로 확장된다. 32비트 환경에서는 32비트 단위로 처리하는 것이 가장 유리하며 스택의 크기가 32비트로 고정되어 있기 때문이다.

리틀 엔디안은 0x34, 0x12의 뒤에 0x00, 0x00를 덧붙이면 간단하게 32비트로 확장된다. 뒤쪽이 더 높은 자리여서 뒤에 붙이는 0은 선행제로가 되어 값에 영향을 미치지 않는다. 이에 비해 빅 엔디안은 선행 제로가 들어갈 공간을 만들기 위해 앞쪽의 0x12, 0x34를 뒤쪽으로 이동시켜야 하므로 여분의 연산이 필요하다.

보다시피 값의 축소나 확장이 일어날 때 리틀 엔디안이 더 편리하고 효율적이다. 반면 값을 구성하는 바이트를 배열처럼 다룰 때는 몇 가지 단점이 있다. 예를 들어 정수형 값을 한 바이트씩 읽어 출력한다고 해 보자.

 

ReadEndian

#include <stdio.h>

 

int main()

{

     int value = 0x12345678;

     char *p = (char *)&value;

 

     // 리틀 엔디안

     for (int i = sizeof(int) - 1;i >= 0;i--) {

          printf("%x ", p[i]);

     }

     puts("");

 

     // 빅 엔디안

     for (int i = 0;i < sizeof(int);i++) {

          printf("%x ", p[i]);

     }

     puts("");

}

실행결과

12 34 56 78

78 56 34 12

 

리틀 엔디안은 높은 자리가 뒤에 있기 때문에 배열의 뒤에서부터 읽는다. 빅 엔디안으로 저장된다면 앞에서부터 자연스럽게 읽으면 된다. 리틀 엔디안은 상식과는 반대 순서로 값이 저장되어 있어 황당한 실수의 원인이 되며 메모리를 직접 조작할 때 항상 주의해야 한다. 한마디로 헷갈린다.

바이트 순서는 큰 값을 작은 단위에 나누어 저장하는 내부적인 방식일 뿐이어서 어떤 방식이 더 우수하다고 할 수는 없다. CPU 설계자가 하드웨어의 구조나 활용 방안 등 여러 가지 상황을 고려하여 둘 중 하나의 방식을 선택한 것 뿐이다.

사실 개발자가 바이트 순서까지 신경쓸 필요는 없다. 리틀 엔디안이 거꾸로 저장하더라도 읽을 때 어차피 다시 거꾸로 읽기 때문에 최초 저장해 놓은 값이 읽혀지는 것은 매한가지이다. 저장 방식의 차이일 뿐 값 자체가 바뀌는 것은 아니어서 별로 신경쓸 필요가 없다.

그러나 특수한 상황에서는 이를 고려해야 하는 경우가 있는데 디버깅중에 메모리를 직접 들여다 본다거나 메모리의 값을 조작할 때이다. 0x1234가 0x34, 0x12로 저장되어 있다고 해서 이상하게 생각하지만 않으면 된다. 또 이기종 컴퓨터간의 네트워크 통신을 할 때는 통신 대상의 엔디안에 맞춰야 하는 번거로움이 있다.

4.부동 소수점

실수는 정수보다 복잡한 구조여서 저장하는 방식도 난해하다. 실수는 부호와 정수부, 소수부로 구성되므로 이 세 부분에 비트를 할당하는 방법을 생각해 볼 수 있다.

32비트를 잘라 각 부분을 저장했다. 부호는 두 가지 경우밖에 없으므로 1비트면 충분하고 정수와 소수를 절반 정도씩 할당한다. 가능한 방법이지만 정수부의 범위가 고작 32000 밖에 안되 큰 수를 표현할 수 없다. 소수부의 범위도 65000까지여서 정밀도가 소수점 이하 다섯 자리 밖에 안된다.

직관적이고 간단하지만 너무 순진하고 치밀하지 못하다. 그래서 이 방법 대신 실수를 가수와 지수로 나누어 표현하는 부동 소수점이라는 질적으로 다른 방법을 사용한다. 실수를 10진 부동 소수점 형태로 표현하면 가수 * 10의 지수승 형태로 표기할 수 있다.

 

고정 소수점 방식

부동 소수점 방식

123.456

1.2345 * 102

0.0123

1.23 * 10-2

1.2345

1.2345 * 100

 

가수는 어떤 수로 구성되어 있는지 값의 모양을 저장한다. 지수는 가수의 어디쯤에 소수점이 있는지를 지정하여 값의 크기를 지정한다. 지수에 따라 소수점이 둥둥 떠서 움직이기 때문에 부동(浮動) 소수점이라고 한다. 이 방식은 C언어뿐만 아니라 모든 프로그래밍 언어나 그래픽 시스템이 준수하는 국제 표준(IEEE-754)으로 지정되어 있다. 다음은 32비트 실수형인 float형의 비트 구성이다.

가수부가 길어 정밀도가 높고 지수부로 1038의 큰 수를 표현한다. 64비트의 double 형은 십진수로 15자리까지의 정밀도를 제공하고 최대 표현수는 10308정도여서 실용적으로도 충분하다. 부동 소수점은 같은 수를 표현하는 지수와 가수의 조합이 여러 벌인 문제가 있다. 다음 수식들은 모두 12.345라는 실수값을 표현한다.

 

12.345*100, 1.2345*101, 0.12345*102, 123.45*10-1, 1234.5*10-2

 

이렇게 되면 두 변수의 상등 비교가 어려워진다. 그래서 한 수를 표현하는 방법은 하나만 존재하도록 가수의 정수부를 한자리로 제한하여 정규화(Normalization)한다. 이 과정을 거치면 12.345는 1.2345*101만 가능해진다. 즉, a.bcd*10n 식으로 소수점이 항상 가수의 첫 번째 바로 다음에 있도록 한다.

직관적인 이해를 위해 10진수를 기준으로 설명했는데 실제 컴퓨터는 2진수를 사용한다. 가수와 지수도 모두 2진수여서 가수는 1 ~ 2 사이의 수로 제한되어 항상 1.xxx의 형태를 띈다. 실수를 구성하는 각 요소는 다음과 같이 구성된다.

 

■ 부호 : 0이 양수이고 1이 음수이되 이 부호는 실수 자체의 부호일 뿐이며 지수의 부호는 아니다.

■ 지수 : 지수가 n일 때 가수부에 2n을 곱한다. 음수 지수는 부호 비트를 따로 쓰지 않고 바이어스를 적용한다. 8비트의 지수에 대해 127의 바이어스가 적용되어 표현 범위는 -127~128까지이다. 최소 지수 -127은 0을 표현하며 최대 지수 128은 무한대를 표현하는 용도로 예약되어 있다.

■ 가수 : 각 자리수에 2의 음수 거듭승으로 가중치가 부여된다. 정규화 규칙에 의해 가수는 항상 이진수 1 ~ 2사이(1.xxx)이며 이 규칙을 만족하기 위해 제일 왼쪽 비트(20자리)는 항상 1이라고 가정한다. 최상위 비트를 저장하지 않는 대신 정밀도는 2배 더 높아진다.

가수의 제일 왼쪽 비트부터 1/2, 1/4, 1/8, 1/16의 가중치를 가지며 이 비트들로부터 계산된 값에 1(20)을 더하면 실제 가수가 된다. 다음 실수는 십진수로 어떤 수인지 계산해 보자.

 

0 01111101 10000000000000000000000

 

부호가 0이므로 일단 양수다. 지수는 125인데 바이어스 127을 빼면 -2이다. 가수의 제일 왼쪽에 1이 생략되어 있어 실제 가수는 110000~이며 1 + 1/2 = 3/2을 표현한다. 이 값을 십진수로 계산하면 다음과 같다.

 

3/2 * 2-2 = 3/2 * 1/4 = 3/8 = 0.375

 

모든 것이 2진수이고 바이어스나 생략된 값을 고려해야 하니 사람이 이 값을 직접 읽기는 무척 어렵다. 하지만 2진수를 잘 다루는 컴퓨터에게는 아주 쉬운 일이다. 다음 예제는 부동 소수점 수의 비트 구조를 덤프하는데 이 예제로 다양한 실수값을 분석해 보면서 float형의 구조를 연구해 보자

 

PrintFloat

#include <stdio.h>

 

void printfloat(float f)

{

     unsigned t;

     char temp[35], bin[35];

 

     // 비트를 다루기 쉽도록 정수형 변수에 대입한다.

     t = *(unsigned *)&f;

 

     // 선행 제로를 포함한 32자리의 2진수 문자열로 변환

     itoa(t, bin, 2);

     memset(temp, '0', 35);

     strcpy(temp + 32 - strlen(bin), bin);

 

     // 부호, 지수 다음에 공백을 하나씩 넣음

     bin[0] = temp[0];

     bin[1] = ' ';

     strncpy(bin + 2, temp + 1, 8);

     bin[10] = ' ';

     strcpy(bin + 11, temp + 9);

 

     printf("실수=%f(%s), ", f, bin);

 

     // 지수 출력

     printf("지수부 = %d\n", (t >> 23 & 0xff) - 127);

}

 

int main()

{

     printfloat(0.375f);

     printfloat(3.14f);

     printfloat(-0.5f);

     printfloat(0.1f);

}

실행결과

실수=0.375000(0 01111101 10000000000000000000000), 지수부 = -2

실수=3.140000(0 10000000 10010001111010111000011), 지수부 = 1

실수=-0.500000(1 01111110 00000000000000000000000), 지수부 = -1

실수=0.100000(0 01111011 10011001100110011001101), 지수부 = -4

 

printfloat 함수는 각 비트를 잘라 문자열로 조립하는데 비트 조작문이 다소 어렵다. 당장 분석까지 해 볼 필요는 없고 학습용으로 사용만 하되 다음에 한가할 때 분석해 보자.

이 결과에서 보다시피 부동 소수점은 10진 실수를 정확히 표현하지 못해 0.1이라는 간단한 수의 비트열이 굉장히 복잡하다. 근본적으로 2진수와 10진수의 수 체계가 다르기 때문이다. 절반씩 줄어드는 각 자리수를 더해 10진수에 딱 맞는 수를 만들 수 없어 아주 낮은 자리까지 내려 가야 한다.

 

float f=0.1f;

printf("%.10f",f);

 

실수 0.1을 출력하면 2의 거듭승으로 정확히 표현할 수 없어 0.1000000015라는 값이 나온다. 사실 이 정도의 오차라면 무시해도 되는 미세한 값이다. 그러나 이런 경미한 값이 모이면 오차가 점점 커진다. 다음 예제를 실행해 보자.

 

FloatError

#include <stdio.h>

 

int main()

{

     float d = 0.0f;

 

     for (int i = 0;i < 1000;i++) {

          d += 0.1f;

     }

     printf("%f\n", d);

}

실행결과

99.999046

 

0.1을 1000번 더하면 100이 되어야 하지만 반복적인 덧셈의 의해 작은 오차가 누적되면 원하는 값과 점점 멀어진다. 십진 실수 0.1f 자체가 정확하지 않기 때문이다. 0.1f * 1000을 바로 계산하면 지수 연산을 직접 하므로 정확하게 100.0이 계산된다.

이런 미세한 오차가 실제 프로그램에서 말썽을 일으키는 경우는 드물다. 정밀도를 요하는 과학 계산이라 할지라도 오차율이 낮아 무시해도 될 정도이다. 그러나 실수는 항상 어느 정도의 오차가 있다는 점을 항상 주지해야 하며 실수끼리 상등 비교 연산을 해서는 안된다.

위 예제에서 루프를 실행한 후 if (d == 100.0f) 라고 비교하면 거짓으로 평가되는데 아무리 비슷한 값이라도 비트열이 다르기 때문이다. 상등 비교 연산을 하는 대신 if (abs(d-100.0) < 0.01) 식으로 부등 비교하여 차이가 오차 범위안이라면 같은 수로 보는 것이 합당하다.

부동 소수점 타입에 대한 또 다른 주의 사항은 범위와 정밀도는 다르다는 것이다. float형이 1038까지 표현할 수 있다고 해서 10진수 38자리수까지 정확하다는 얘기는 아니다. 지수의 범위가 10진수로 38자리라는 것이지 가수의 정밀도는 기껏해야 10진수로 7자리 정도밖에 되지 않는다.

 

float f = 123456789.123456789f;

 

이 선언문은 float형 변수에 긴 실수를 대입하는데 실제 이 변수에 기억되는 값은 123456792.0이다. 8자리 이상의 값은 반올림되어 오차가 발생한다. 이런 경우는 가수부가 충분히 큰 double형을 사용해야 한다. double형은 십진수로 15자리까지 유효하다. 다음 예제를 보자.

 

FloatError2

#include <stdio.h>

 

int main()

{

     float f1, f2, f3;

     f1 = 123456.0f;

     f2 = 0.0001f;

     f3 = f1 + f2;

     printf("f1=%f\nf2=%f\nf3=%f\n", f1, f2, f3);

}

실행결과

f1=123456.000000

f2=0.000100

f3=123456.000000

 

123456.0과 0.0001을 더하면 123456.0001이 되어야 하지만 결과는 123456.0이 되어 더하나 마나이다. f1과 f2는 float형에 맞는 정밀도를 가지지만 두 값의 지수차가 심해 더한 결과는 float형에 맞지 않다. float형의 비트 구조를 분석해 보면 이 예제의 결과가 왜 이렇게 나오는지 설명할 수 있다. 충분한 정밀도를 확보하려면 가급적 큰 타입을 사용하는 것이 좋다.

실수는 제한된 비트수로 최대한 크면서도 정확한 값을 표현하기 위해 복잡한 구조로 되어 있다. 다행히 수치 연산 보조 프로세서가 실수를 알아서 연산하고 해석해 주므로 우리가 실수의 비트를 직접 해석할 일은 거의 없다. 실수의 내부를 이해하면 다음 코드가 잘못되었다는 것은 분명히 알 수 있다.

 

double d = 123.456;

int *pi = (int *)&d;

printf("%d\n", *pi);

 

이 코드의 결과로 123이 나오기를 기대한다면 아직도 비트의 세계를 이해하지 못한 것이다. 정수와 실수는 비트 구조가 완전히 다르다.