복잡한 수식

증감 연산은 사용 빈도가 높아 CPU도 기계어 차원의 증감 명령을 별도로 제공한다. 어떤 값에 1을 더해 다시 대입하는 a = a + 1(어셈블리어로 ADD [a], 1)보다 값을 1 증가시키는 a++(어셈블리어로 INC [a])가 훨씬 빠르고 명렁어도 짧다. 다행히 C 언어 차원에서는 컴파일러가 a = a + 1을 a++로 바꿔 컴파일할 정도로 똑똑하기 때문에 별 차이가 없다.

증감 연산자는 그 당시 다른 언어에는 없는 독특한 연산자였으며 예상외로 편리하고 효율적이어서 C언어의 대중화에 큰 기여를 했다. 그러나 복잡한 수식 내에서 증감 연산자를 사용하면 증감 순서가 애매해져 뜻하지 않은 부작용이 발생하기도 한다. 다음 예제의 실행 결과를 예측해 보자.

#include <stdio.h>

int main()

{

int i = 3;

printf("%d, %d\n", i, ++i);

}

3의 값을 가지는 i를 두 번 출력하되 한번은 그냥 출력하고 한번은 전위형으로 i를 증가시켜 출력했다. 대부분 3, 4를 예상하겠지만 실제 결과는 4, 4이다. 이렇게 되는 이유는 C는 인수를 전달할 때 뒤쪽 인수부터 전달하기 때문이다. ++i가 먼저 실행되어 4가 전달되고 다음으로 이미 4가 되어 버린 i를 전달한다.

C 표준에 인수 전달 순서는 지정되어 있지 않으며(Unspecified) 대부분의 컴파일러는 가변 인수를다루기 위해 뒤쪽 인수부터 전달한다. 컴파일러마다 인수 전달 순서가 다르기 때문에 수식내에서 ++ 연산자를 사용하면 이식성에 불리하다. 이런 골치아픈 문제를 신경쓰기 싫으면 수식 내에서 증감 연산자를 쓰지 말고 평이하게 풀어서 쓰는 것이 좋다.

int i = 3;

printf("%d, ",i);

++i;                                 // 또는 i++;

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

코드가 좀 길어지지만 의도한대로 잘 실행되며 부작용도 없고 남이 봐도 코드를 쉽게 해석할 수 있다. 다음 수식을 보자.

b = (++a + 1) * a++;

b = a++ + ++a;

두 식 모두 문법적으로 아무 문제가 없으며 엄격히 따져 보면 결과를 예측할 수도 있다. 그러나 뭔가 불안해 보이고 어떤 의도로 작성한 코드인지 한눈에 알아보기 어렵다. 이런 코드는 컴파일러마다 평가 방법이 달라 이식성에도 분리하다.

현란하고 복잡한 코드를 쓴다고 해서 실력이 좋은 것은 아니며 오히려 호기심에 가득찬 철부지 초보자가 제 멋에 겨워 이런 코드를 즐겨 쓴다. 경험있는 개발자는 가급적 코드를 단순하게 작성하며 읽기 어려운 코드를 쓰지 않는다.

=과 ==의 구분

대입 연산자 = 과 관계 연산자 == 은 모양이 비슷하지만 동작은 완전히 달라 주의가 필요하다. 다음 두 문장을 보자.

a = a + 1;

a == a + 1;

위의 문장은 a의 값에 1을 더해 다시 a에 대입한다는 뜻이며 흔히 많이 쓰는 문장이다. 그러나 아래쪽의 문장은 a와 a + 1이 같은지 비교하라는 문장이며 1은 0이 아니어서 항상 거짓이다. 조건문을 쓸 때 두 연산자를 잘 구분해야 한다.

printf("정수를 입력하세요 : ");

scanf("%d",&i);

if (i = 7)

printf("7을 입력했습니다.\n");

값을 입력 받은 후 if (i == 7)로 비교해야 하는데 if (i = 7)로 대입하는 실수를 했다. 문제는 이 코드가 합법이라 에러가 발생하지 않는다는 점이다. 대입 연산자는 i에 7을 대입한 후 그 결과를 리턴하며 7은 0이 아니므로 이 조건은 항상 참이다. C는 별도의 진위형이 없어 정수를 조건식으로 사용하며 대입 연산자는 정수를 리턴하니 문법적으로 문제가 없다.

의도와는 다르게 코드를 작성했지만 에러는 고사하고 경고 하나도 발생하지 않는다. 이런 코드를 미처 발견하지 못하면 나중에 심각한 에러의 원인이 되기도 한다. 두 연산자를 혼동해서 사용하는 경우는 초보자뿐만 아니라 숙련자에게도 빈번히 일어난다. 그래서 변수와 상수를 비교할 때 다음 형식으로 쓰기도 한다.

if (7 == i)

== 연산자는 교환법칙이 성립하며 값을 바꾸지 않으므로 좌변에 상수가 오고 우변에 변수가 와도 상관없다. 만약 연산자를 잘못 사용하여 if (7 = i)로 쓰면 컴파일러가 즉시 7은 좌변값이 아니라는 에러 메시지를 출력하며 개발자는 즉시 자신의 실수를 알아채고 잘못된 코드를 수정할 수 있다. 보기에 조금 어색하지만 실수를 미연에 방지할 수 있어 많이 애용하는 코드이다.

오래된 소스에 이런 코드가 보이면 당시에는 실수 방지를 위해 흔히 사용했던 기법 정도로 이해하면 된다. 그러나 최근의 컴파일러는 경고 수준을 높이면 조건문에 대입식을 썼을 때 경고로 처리하는 기능이 있어 과거에 비해서는 덜 위험해졌다.

쇼트 서키트

C의 논리 연산자는 속도 향상과 안전을 위해 불필요한 연산은 하지 않는다. 변수 a가 5 ~ 10의 범위에 있는지 점검하려면 두 개의 조건을 &&로 연결해서 동시에 점검해야 한다. 논리 연산자의 피연산자는 왼쪽부터 평가된다.

if (a > 5 && a < 10)

우선 좌변을 평가하여 a가 5보다 큰지 점검한다. a가 5보다 크다면 전체식의 진리 판단을 위해 우변의 조건식을 더 점검해 보겠지만 그렇지 않다면 우변은 아예 평가할 필요가 없다. 예를 들어 a가 2라면 이값은 5보다 크지 않으므로 첫 번째 조건부터 거짓이다. 좌변의 조건이 거짓이면 우변의 진위와는 상관없이 전체식은 이미 거짓으로 결정되었으므로 우변은 평가할 필요가 없다.

|| 연산자도 마찬가지이다. if (a == 3 || b == 5) 조건문을 평가할 때 a가 3이라면 좌변이 참이므로 우변의 진위 여부에 상관없이 전체 조건식의 값은 이미 참으로 결정났다. b의 값이 무엇인지 볼 필요없이 전체식을 참으로 판정하면 된다. && 연산자는 좌변이 거짓이면 전체를 거짓으로 평가하며 || 연산자는 좌변이 참이면 전체를 참으로 평가한다.

이미 결정난 값에 대해 불필요한 연산을 생략함으로써 실행 속도를 높이는 기법을 쇼트 서키트(Short Circuit)라고 한다. 컴파일러에 따라 지원 여부가 다른데 대부분의 컴파일러는 지원한다. 그깟 조건문 하나 생략하는게 얼마나 차이가 있을까 싶겠지만 우변이 함수 호출문을 때는 굉장한 차이가 있으며 안전성에도 큰 역할을 한다. 다음 조건문을 보자.

if (a != 0 && b/a == 3) 명령;

a가 0이 아니고 b를 a로 나눈 값이 3일 때 명령을 실행하는 문장이다. a가 0이라면 좌변이 거짓이므로 쇼트 서키트에 의해 b/a 연산식은 아예 평가되지도 않는다. 쇼트 서키트 기능이 없다면 a가 0인 상태에서 b/a 연산을 하게 되어 치명적인 예외가 발생한다. 그래서 b를 a로 나누기 전에 a가 0이 아니라는 조건을 먼저 점검하여 예외를 피해가도록 했다. 위 코드를 풀어쓰면 다음과 같다.

if (a != 0) {

if (b/a == 3) 명령;

}

쇼트 서키트는 컴파일러가 알아서 적용하므로 개발자가 굳이 몰라도 상관없다. 그러나 이 기능을 잘 이용해 먹으면 더 효율적인 코드를 작성할 수 있다. 논리 연산자는 교환 법칙이 성립하므로 좌우 조건식을 바꾸어도 결과는 항상 같다. 그러나 좌변이 우변의 실행 조건이 되는 경우는 조건의 나열 순서에 신경써야 한다. 다음 코드는 아주 위험하다.

if (b/a == 3 && a != 0) 명령;

점검하는 조건에 따라 평가 시간에서 차이가 있을 경우 간편한 쪽을 왼쪽에 배치해야 한다. 예를 들어 A 조건은 단순히 변수값만 평가하며 B 조건은 지구 반대편에 있는 웹 서버가 동작하는지 점검한다고 해 보자. 이 두 조건을 논리 연산자로 연결할 때는 (A && B)나 (A || B)로 쓰는 것이 유리하다.

순서를 바꾸어 B 조건을 먼저 점검하면 결과는 같아도 실행 시간이 낭비된다. (B && A) 조건식의 진위 판단을 위해 웹 서버에 접속하여 동작하고 있다는 것을 알아 냈는데 A가 거짓이라면 B를 평가하는 시간만 버린 셈이다. 쉽게 조사할 수 있는 조건이 먼저 와야 한다. 또 반드시 실행해야 할 조건도 앞쪽에 배치해야 한다.

if (a == 8 || (ch=getch()) != ' ') {

switch (ch) {

....

}

}

원래 의도는 a가 8이거나 입력받은 문자 ch가 공백이 아니면 ch값에 따라 분기하는 구조이다. 이 코드에서 a가 8이면 getch는 아예 호출되지 않으므로 ch는 쓰레기값을 가지고 이후의 동작은 예측할 수 없다. getch는 반드시 호출되어야 하므로 조건문의 순서를 바꾸어야 하며 그보다는 ch = getch() 호출문을 if문 이전으로 빼서 단순화하는 것이다.

void 이중 포인터

void ** 타입은 실전에서 사용 빈도가 낮아 실용성은 별로 없지만 포인터의 이해도를 높이는 학술적 가치가 있는 주제이다. void **를 확실하게 이해했다면 포인터는 거의 정복했다고 생각해도 상관없되 모른다고 해서 걱정할 필요는 없다. 실무를 하다 보면 자연스럽게 이해될 때가 올 것이다.

void **는 void *타입을 가리키는 유도 타입이다. void **vpp; 로 선언한 vpp의 대상체는 임의의 대상을 가리키는 void *타입의 변수이다. 비슷해 보이지만 void *와는 달리 가리키는 대상체의 타입이 void *로 정해져 있고 대상체의 크기도 명확하게 알고 있다. 따라서 vpp는 void형 포인터에 적용되는 규칙 대신 일반 포인터의 규칙이 적용된다.

임의 타입의 포인터를 대입받을 수 없고 반드시 void *형 변수의 번지만 대입받을 수 있다. 또한 대상체가 정해져 있으므로 *연산자로 읽거나 변경할 수 있고 ++, --, +n 연산으로 앞 뒤 요소로 이동할 수 있으며 같은 void ** 타입끼리 대입, 비교, 뺄셈도 가능하다. 다음 예제를 통해 vpp와 vpp의 대상체에 대해 연구해 보자.

#include <stdio.h>

int main()

{

void *vp;

void *av[5];

void **vpp;

int i, *pi = &i;

vpp = &vp; // 가능

vpp = av; // 가능

vpp++; // 가능

*vpp; // 가능

vpp = &pi; // 불가능

**vpp; // 불가능

}

void **로 선언된 vpp가 대입받을 수 있는 값은 void *형 변수인 vp의 번지, void * 배열 av의 선두 번지 등이다. int **ppi가 int *pi의 번지나 int *ar[5] 배열을 대입받을 수 있는 것과 같다. vpp가 void *형의 av 배열을 가리키는 상황은 다음과 같다.

av 배열의 각 요소는 void * 타입이므로 임의 타입의 변수에 대한 번지를 가진다. 따라 av 배열 요소가 가리키는 값을 읽으려면 캐스트 연산자가 있어야 하며 ++, -- 연산도 적용할 수 없다. 하지만 vpp가 가리키는 대상체는 void *로 정해져 있어 캐스트 연산자없이 *vpp로 요소의 값을 읽을 수 있고 포인터는 부호없는 4바이트 길이를 가지므로 vpp 자체를 증가시켜 av의 다음 요소로 이동할 수도 있다.

void *는 임의 변수의 번지를 대입받을 수 있지만 void **는 임의 포인터의 번지를 대입받을 수 없다. void형 이중 포인터가 가리키는 대상체는 void *로 고정적이어서 int *형 변수인 pi의 번지를 대입받을 수는 없다. 이게 가능하다면 **vpp로 정수값을 읽을 수 있어야 하는데 vpp가 가리키는 포인터의 대상체가 정해져 있지 않아 이 연산은 불가능하다. 임의의 포인터를 가리키는 변수의 타입은 여전히 void *이다.

void *는 임의의 타입을 모두 가리킬 수 있는데 포인터 타입도 포함되며 포인터 변수도 번지가 있으니 포인터의 번지를 void * 변수가 가리킬 수 있다. void *vp가 int *pi를 가리키는 상태에서 대상체를 읽고 싶다면 **(int **)vp로 vp를 정수형 이중 포인터로 캐스팅한 후 *를 두 번 적용하여 pi가 가리키는 값을 읽는다.

*vpp로 대상체인 void *를 읽는 것은 가능하지만 **vpp로 vpp가 가리키는 포인터의 대상체를 읽지는 못한다. *vpp로 읽은 void *의 대상체 타입을 알 수 없기 때문이다. 정 읽고자 한다면 *(int *)*vpp 형식으로 일단 void *를 읽고 포인터를 원하는 타입으로 캐스팅해서 다시 * 연산자를 적용한다. 다음 예제는 void *의 현실적인 사용예이다.

#include <stdio.h>

#include <malloc.h>

void alloc(void **mem, size_t size)

{

*mem = malloc(size);

}

int main()

{

void *vp;

alloc(&vp, sizeof(int));

*(int *)vp = 1234;

printf("%d\n", *(int *)vp);

free(vp);

}

메모리를 대신 할당해 주는 함수를 만들 때 이 함수가 받아야 할 인수의 타입이 void **이다. 예제의 alloc 함수는 malloc을 단순히 호출만 하지만 복잡한 연산을 통해 필요한 메모리양을 계산하거나 할당 후 추가 동작을 할 수도 있다. main에서 동적 할당된 메모리의 번지를 저장하기 위해 void *형의 vp를 선언하고 이 변수를 참조 호출로 넘기기 위해 &vp로 전달한다. 그러므로 alloc 함수의 인수는 void **일 수밖에 없다.

이차 배열 할당

동적 할당을 통해 실행중에 원하는 크기의 배열을 생성할 수 있다. int ar[5]로 정적 선언하는 문장의 크기 5를 실행중에 필요한만큼 지정 가능하다. 그렇다면 2차원 배열도 동적으로 할당할 수 있을까? 이 내용은 다소 이론적이라 실용성은 떨어지며 굳이 몰라도 상관없지만 배열과 포인터에 대한 이론적인 연구를 위한 학술적인 주제여서 연구해 볼 가치가 있다.

char ar[3][4] 선언문의 상수 3과 4를 실행중에 원하는 크기대로 결정하고 싶다고 하자. 이만큼의 메모리를 만들려면 malloc(3 * 4 * sizeof(char)) 호출로 12바이트를 할당하면 된다. 문제는 malloc이 리턴하는 포인터를 어떤 타입의 변수로 받아야 하는가이다. malloc은 어차피 void *를 리턴하므로 원하는 타입으로 캐스팅 가능하다. 일단 다음과 같이 해 보자.

char *p = (char *)malloc(3 * 4 * sizeof(char));

배열의 최종 요소가 char 타입이므로 char *로 받았다. 그러나 이렇게 할당한 배열은 길이 12의 문자형 일차 배열이지 2차원 배열이 아니다. 원래 할당하려고 했던 char[3][4]는 길이 4의 문자열 3개를 의도한 것이어서 메모리 크기만 같을 뿐 모양이 다르다. 이 배열을 동적으로 할당하려면 배열 포인터로 받아야 한다.

#include <stdio.h>

#include <malloc.h>

#include <string.h>

int main()

{

char(*p)[4] = (char(*)[4])malloc(3 * 4 * sizeof(char));

strcpy(p[0], "dog");

strcpy(p[1], "cow");

strcpy(p[2], "cat");

for (int i = 0; i<3; i++) puts(p[i]);

free(p);

}

dog

cow

cat

크기 4의 문자형 배열을 가리키는 타입을 크기 3으로 할당했다. 각 부분 배열에 문자열이 잘 저장되는지 3글자의 문자열을 복사하고 다시 출력해 확인했다. 이 예제에서 할당한 p는 char ar[3][4] 배열을 동적으로 할당한 것이며 2차원 배열과 자격이 같다.

그러나 이 예제가 할당한 p는 사실 2차원 배열이 아니라 p의 부분 배열 크기가 컴파일중에 결정되었기 때문에 1차원 배열에 더 가깝다. 배열 자체의 크기인 3은 실행중에 마음대로 지정할 수 있어 변수나 사용자가 입력한 값을 쓸 수 있다. 그러나 배열 타입의 크기인 4는 변수를 쓸 수 없다. 다음 코드를 보자.

int n = 3,m = 4;

char (*p)[m] = (char (*)[m])malloc(n * m * sizeof(char));

free(p);

이렇게 해야 진정한 동적 할당이지만 안타깝게도 이 코드는 컴파일되지 않는다. 왜냐하면 배열 포인터의 부분 배열 크기는 상수로만 줄 수 있기 때문이다. char (*p)[m] 선언문부터 에러이다. p가 포함할 부분 배열의 크기는 실행중에 결정할 수 없으며 컴파일할 때 미리 결정해야 한다. 모든 포인터는 대상체의 크기를 알아야 하는데 p는 대상체 크기를 알 수 없다. 이 코드가 컴파일되지 않는 이유는 int ar[m]이 컴파일되지 않는 이유와 같다.

그래서 p는 2차원 배열이 아니라 크기가 정해진 1차원 배열을 요소로 가지는 1차원 배열, 즉 배열의 배열이다. 두 첨자의 크기를 실행중에 마음대로 변경할 수 없어 2차원 배열을 할당한 것은 아니다. 사용자 정의 타입을 정의한 후 할당해 보면 이를 분명히 확인할 수 있다.

typedef char c4[4];

c4 *p=(c4 *)malloc(3 * sizeof(c4));

c4를 크기 4의 문자형 배열 타입으로 정의하고 p는 c4의 1차원 배열로 동적 할당했다. p 배열의 크기인 3은 실행중에 결정할 수 있지만 c4 선언문의 4는 타입의 일부여서 컴파일중에 결정되는 상수여야 한다. 원래 의도했던대로 두 첨자를 실행중에 자유롭게 지정하려면 이중 포인터를 사용해야 한다.

#include <stdio.h>

#include <malloc.h>

#include <string.h>

int main()

{

int n = 3, m = 4;

char **p;

p = (char **)malloc(n * sizeof(char *));

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

p[i] = (char *)malloc(m * sizeof(char));

}

strcpy(p[0], "dog");

strcpy(p[1], "cow");

strcpy(p[2], "cat");

for (int i = 0; i < n; i++) puts(p[i]);

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

free(p[i]);

}

free(p);

}

문자형 이중 포인터 p를 선언하고 p를 먼저 동적 할당한다. 이때 p 자체의 크기는 변수로 지정할 수 있으며 3으로 정의된 n을 적용했다. 이 할당에 의해 p는 크기 3의 문자열 포인터 배열이 된다. p를 할당한 후 p의 각 요소를 다시 동적 할당하되 이때는 m의 크기만큼 할당한다. 두 첨자 n과 m이 모두 변수이므로 실행중에 2차원 배열의 폭과 높이를 원하는대로 지정할 수 있다. p가 메모리에 생성된 모양은 다음과 같다.

부분 배열이 흩어져 있지만 실행중에 할당한 2차 배열이며 정적으로 할당된 char[3][4]와 자격이 같다. 그러나 완전히 같지는 않는데 정적 배열은 부분 배열이 모두 일정한 직사각형 배열이지만 이중 포인터를 사용한 배열은 부분 배열의 크기를 각각 다르게 지정할 수 있는 래기드 배열이다.

원래의 논의로 돌아가 이차원 배열을 동적으로 할당할 수 있는가에 대한 진위 여부를 가려 보자. 문법적인 면에서만 보면 두 첨자의 크기를 실행중에 결정할 수 없어 이차원 배열을 한번에 할당하는 것은 불가능하다. 하지만 실무적인 면에서 보면 이차 배열처럼 동작하는 이중 포인터로 동일한 형태의 배열을 만들 수는 있어 가능하다고 볼 수도 있다.

&ar

배열명은 배열의 시작 번지를 가리키는 포인터 상수이며 배열의 시작 위치를 알고 싶다면 별도의 연산자없이 배열 이름을 사용한다. 예를 들어 int ar[5]로 선언된 배열의 선두 번지를 정수형 포인터에 대입하고 싶다면 int *pi = ar;로 바로 대입하면 된다.

그렇다면 배열명에 & 연산자를 붙인 &ar은 어떤 의미가 있을까? ar은 포인터 상수이며 상수는 번지를 가지지 않아 & 연산자를 쓸 수 없는 것이 원칙이며 실제 클래식 C에서 &ar은 에러로 처리되었다. 그러나 ANSI C 이후에는 배열이 &의 피연산자가 될 때 상수가 아닌 배열 그 자체를 가리키도록 변경되어 &ar 표현이 가능해졌다. ar과 &ar이 어떻게 다른지 연구해 보자.

int ar[5] = {1, 2, 3, 4, 5};

printf("%p\n", ar);

printf("%p\n", &ar);

크기 5의 정수형 배열 ar을 선언해 두고 ar과 &ar의 실제 번지를 출력했다. 메모리 상황에 따라 위치는 달라지지만 두 번지가 같다는 것은 확인할 수 있다. 그렇다고 해서 ar과 &ar의 자격이 같은 것은 아니다.

int ar[5] = {1, 2, 3, 4, 5};

int *pi;

pi = ar; // 가능

pi = &ar; // 에러

정수형 포인터 pi는 ar을 대입받을 수 있지만 &ar은 대입받을 수 없다. 대입이 안된다는 얘기는 좌우변의 타입이 다르다는 뜻이다. ar은 정수형 배열의 시작 번지를 가리키는 포인터 상수이며 정확한 타입은 int * const이고 대상체는 int이다. 반면 &ar은 대상체가 크기 5의 정수형 배열이며 정확한 타입은 int (*)[5] const이다.

양변의 타입이 다르니 pi에 &ar을 대입할 수 없다. 꼭 하려면 (int *)&ar로 캐스팅해서 대입하거나 pi의 타입을 int (*pi)[5]로 바꾸어 배열 포인터로 선언해야 한다. 다음 예제로 &ar이 어떤 의미를 가지는지 연구해 보자.

#include <stdio.h>

#include <malloc.h>

#include <string.h>

int main()

{

int ar[5] = { 1,2,3,4,5 };

int *p1 = ar;

int(*p2)[5] = &ar;

printf("p1 = %p\n", p1);

printf("p2 = %p\n", p2);

p1++;

p2++;

printf("p1 = %p\n", p1);

printf("p2 = %p\n", p2);

}

p1 = 0078FC70

p2 = 0078FC70

p1 = 0078FC74

p2 = 0078FC84

정수형 배열 ar의 번지를 가지는 p1과 정수형 배열의 포인터 &ar의 번지를 가지는 p2를 선언하고 두 변수의 초기 번지와 1증가시킨 후의 번지를 출력했다. p1, p2는 최초 같은 번지를 가리키고 있지만 1증가했을 때 번지가 달라진다. p1은 정수형을 가리키므로 대상체의 크기인 4만큼 증가하지만 p2는 크기 5의 정수형 배열을 가리키고 있으므로 20바이트(0 x14)만큼 증가한다.

&ar은 ar을 부분 배열로 가지는 가상의 전체 배열에 대한 이차 배열 포인터 상수이다. int *pi = &i 선언문의 pi가 i를 첫 번째 요소로 가지는 가상의 정수 배열에 대한 포인터인 것과 같다. ar은 정수를 가리키지만 &ar은 정수형 배열을 가리킨다는 점이 다르다. 대상체 크기가 다르므로 증감에 의해 이동하는 크기도 다르다.

&ar의 정체를 알았으면 다음 코드를 점검해 보자. scanf는 참조 호출을 사용하므로 정수형이나 실수형 변수에 대해서는 & 연산자를 붙여 주소를 가르쳐 주어야 한다. 그러나 문자열을 입력받을 때는 문자 배열 자체가 포인터이므로 & 연산자를 붙이지 않는다.

char name[20];

scanf("%s",name);

이 코드가 정석이지만 기본형처럼 scanf("%s",&name);으로 써도 아무 이상없이 잘 실행된다. 왜냐하면 name과 &name의 주소가 우연히 같기 때문이다. 가변 인수 함수는 인수의 타입보다는 서식을 따르기 때문에 &name이라고 써도 %서식에 대응되는 문자형 배열로 인식하며 번지가 같으니 동작도 정상적이다. 하지만 문법적으로는 분명 틀린 것이며 정 &를 붙이려면 &name[0]로 해야 옳다.

기정의 스트림

스트림은 파일 뿐 아니라 키보드나 모니터처럼 바이트를 연속으로 입출력하는 물리적인 장치까지 포괄한다. 그래서 고수준 입출력 함수로 장치까지 다룰 수 있다. 장치 스트림은 항상 존재하므로 따로 열거나 닫을 필요없이 다음과 같이 정의된 표준 스트림을 사용한다.

이름	설명	버퍼
stdin	표준 입력	사용
stdout	표준 출력	미사용
stderr	표준 에러	미사용

미리 정의되어 있는 스트림이라하여 기정의 스트림(Predefined Stream)이라고 부른다. FILE *를 받는 모든 함수에 표준 스트림을 사용할 수 있다.

#include <stdio.h>

int main()

{

char buf[256];

fputs("문자열을 입력해 보시오 : ", stdout);

fgets(buf, 256, stdin);

fputs(buf, stderr);

}

문자열을 입력해 보시오 : hello

hello

fgets, fputs 함수는 스트림으로 문자열을 입출력하는데 fopen으로 연 FILE 포인터 대신 기정 스트림인 stdin, stdout을 주면 키보드와 화면으로 입출력한다. fget는 키보드가 마치 파일인 것처럼 사용자가 입력한 일련의 문자를 입력받아 buf에 저장하고 fputs는 버퍼에 저장된 문자열을 화면으로 출력한다. fgets는 입력받을 최대 길이를 지정할 수 있어 scanf보다 더 안전하다.

에러 메시지를 출력하는 stderr의 디폴트 설정은 표준 출력 스트림인 stdout과 같아 화면으로 출력된다. 이 스트림을 프린터나 파일로 재지향(Redirection)하면 에러 메시지만 별도의 장치로 보낼 수 있어 디버깅에 유용하다. 요즘은 통합 개발 환경이 워낙 잘 되어 있어 에러 스트림을 잘 사용하지 않지만 싱글 테스킹 환경에서는 실행 결과와 에러 메시지를 분리하여 출력하곤 했다.

volatile

volatile 지정자는 변수의 최적화를 금지한다. const에 비해 상대적으로 사용 빈도가 떨어지는데 어떤 경우에 이 지정자가 필요한지 다음 코드를 보자.

double value;

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

value = sqrt(k) + log(m);

// do something

}

반복적인 루프에서 value의 값을 계산하여 사용한다. value는 루프 제어 변수를 참조하지 않으며 외부에서 주어진 k와 m만 참조하므로 루프 실행중에는 늘 같은 값이다. 바뀌지도 않을 값을 매 루프마다 일일이 계산하는 것은 분명 낭비이므로 다음과 같이 수정하는 것이 합리적이다.

double value = sqrt(k) + log(m);

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

// do something

}

루프로 들어가기 전에 value값을 미리 계산해 놓고 루프 내부에서는 결정된 value값을 사용하기만 한다. 이렇게 해도 실행결과는 같다. 똑똑한 컴파일러는 루프 내부에서 상수인 값을 미리 딱 한번만 계산하는 코드로 바꾸어 최적화를 수행한다. 개발자가 위 코드를 작성해도 컴파일러가 알아서 아래 코드로 바꿔준다. 두 코드는 사실상 실행 속도만 다를 뿐 동작은 같다.

그러나 과연 두 코드가 정말 아무 차이가 없을까? 대개의 경우는 똑같은 코드이지만 아주 민감한 상황에서는 다른 결과가 나타날 수도 있다. 대표적인 예는 여러 개의 스레드가 병렬적으로 실행되는 멀티 스레드이다. 이 코드만 보면 분명 최적화해도 상관없지만 외부 스레드에서 k나 m의 값을 변경한다면 매번 계산하는 것과 미리 계산해 놓는 것은 결과가 달라진다.

이럴 때 컴파일러의 최적화를 금지하는 지정자가 바로 volatile이다. 이 지정자가 붙어 있는 변수에 대해서는 컴파일러가 어떠한 최적화도 하지 않으며 개발자가 작성한 코드를 액면 그대로 컴파일한다. value 변수 선언문에 volatile을 붙여 두면 설사 이 변수 계산문이 비효율적이거나 불필요해 보이더라도 절대 건드리지 않는다.

volatile double value;

volatile 지정자의 의미를 한마디로 표현하면 "까불지 말고 시키는대로 해" 이런 뜻이다. 이 지정자가 반드시 필요한 상황은 공유 정보가 많은 복잡한 멀티 스레드 프로그램이거나 하드웨어 인터럽터를 다루는 디바이스 드라이버 정도여서 웬만한 규모에서는 잘 사용되지 않는다.