define, const 등은 많이 사용할수록 좋습니다.
알고 계신대로 여러군데서 사용할 때 한번에 변경/유지보수 하기도 좋고
숫자(매직 넘버) 대신 문자로 그 숫자가 의미하는 바를 알아볼 수 있기 때문이죠

프로그램 안의 상수는 웬만하면 이런 define이나 const로 바꾸는 것이 좋습니다.

물론 속도가 느려지거나 그런 일은 없습니다.
(그리고 고작 몇백개로 컴퓨터가 느려진다거나 하는 머신이 아닙니다;;)

define은 전처리기에서 처리되므로, 느려질리 없습니다. 느려진다면 컴파일 시간이 좀 더 걸릴뿐이겠죠.

일반적으로 C프로그램은 전처리기 -> 컴파일러 -> 링커 순으로 처리되어 실행파일이 만들어집니다. 수행속도에 지장을 주는 부분은 컴파일러에서 생성된 코드에 삽질(?)이 들어가 있을 경우가 되겠습니다. 위에서 예로 적어주신

#define VALUE 0.125
#define VALUE2 360

#define RESULT (VALUE * VALUE2)

....
    double result = RESULT;
....

라는 (.... 은 생략입니다. ^^;) 코드가 있을 때, 이녀석은 전처리기를 거치면서 다음과 같이 바뀝니다.

(#define 문은 줴다 전처리기를 통과하고 나면 사라집니다)
....
    double result = 45; <--- 요기에 0.125 * 360 의 결과가 들어갑니다.
....

따라서.. 전처리기에서 별 난리를 다 치더라도(물론 거기서 함수를 호출해버리면 말짱 도루묵입니다. 예를들어 #define RESULT (cos(VALUE * VALUE2)) 이런식 처리를 했다면 이녀석은 double result = (cos(45)) 로 변환을 해 놓기 때문에.. 시간을 잡아 먹습니다.), 실행시점에서 퍼포먼스를 갉아먹지 않는답니다.

define은 속도가 전혀 느려지지 않습니다.
컴파일하기 전에 이미 define문들을 사용한 부분은 모두 다 원래 내용으로 대치됩니다.

#define PI 3.14f
float a = PI;
이거는, 컴파일 시점 이전에 이미
float a = 3.14f;
이렇게 바뀌어서 컴파일됩니다. 성능상의 페널티가 있을 수가 없죠.

그리고 define 문의 사용은 최대한 적절한 선에서 줄이는 게 좋습니다.
어떤 단어로 공통적인 값을 지정하고 싶다면, enum 이나 const 변수 선언이 낫고,
함수의 의미로 매크로를 쓰고싶을 땐 inline 함수를 쓰는 편이 낫습니다.

enum은 디버깅중에 그 단어 자체가 조사식에서 나오니까 바로 알아보기 쉽구요, 나름대로 형 체크도 되기 때문에 꽤 괜찮습니다.

그리고 함수처럼 사용하지 않는 이유는 디파인문을 사용한 매크로는 치명적 단점을 안고 있기 때문인데요,
일단 개발환경상에서 디버깅을 찍을 수 없으며 의외의 상황이 자주 발생한다는 점이 있습니다.

#define PLUS(a, b) a + b
int x = PLUS(3, 4) * 5;

이렇게 하면, 함수로 썼다면 당연히 35가 답이겠지만 이건 23이 나와버립니다. 매크로는 컴파일전에 원래내용으로 완전 대치된다는 걸 생각해보면 알 수 있습니다.
이건 단순한 예라서, '에이 저런 일 정도야...' 할지도 모르지만, 나중에는 복잡한데서 저런거 중간에 하나 끼면 모릅니다-_-; 디버그도 안 걸리구요.

악.. 확인해봤더니 틀렸네요 -_-;; double result = 45; 가 아니라 double result = (0.125 * 360); 으로 치환됩니다. (단순 치환인 관계로..) 허나.. 전처리기가 저 삽질을 해놨다손 치더라도, 우리의 컴파일러가 버티고 있는 관계로, 저런 상수 * 상수 따위는 그 몫으로 치환하여 기계어 코드를 만들어 냅니다. ^^; 즉 결과는 double result = 45; 가 된다고 보시면 되겠지요.

답을 잘못 적은 댓가로 좀더 적어보자면.. 아래의 파일이 두개 있습니다. 각각 test.h 랑 test.cpp 구요..

// test.h
#define A 50
#define B 30

#define C A * B

void printC();

// test.cpp
#include "test.h"

void main() {
        printC();
}

void printC() {
        printf("C=%dn", C);
}

이놈을 Visual C++ 6.0의 커맨드라인 컴파일러인 cl.exe 를 이용해서 전 처리기만 통과시키면 아래처럼 바뀝니다. (cl.exe /P test.cpp 라고 하면 전처리 과정만 수행하고, 결과를 test.i 로 출력해줍니다.)

// test.i
#line 1 "test.cpp"
#line 1 "test.h"




void printC();
#line 2 "test.cpp"

void main() {
        printC();
}

void printC() {
        printf("C=%dn", 50 * 30);
}

보시면 아시겠지만, test.h 랑 test.cpp 가 합해졌습니다. 그리고 test.h 안에 있던 #define들이 줴다 사라지고, 선언되었던 상수를 사용하던 곳에는 실제 값으로 치환 되었습니다.
저기서 보면 50 * 30 이 남아서 실행파일이 만들어질 때 곱하기가 한번 더 들어가지 않을까? 하고 걱정하실 수 있겠습니다만...

생성된 코드를 보시면 (cl.exe /Fa test.asm test.cpp 라고 하면 컴파일 과정중에 생성되는 어셈블리어 소스가 나옵니다.)

....
?printC@@YAXXZ PROC NEAR                                ; printC
; Line 8
        push        ebp
        mov        ebp, esp
; Line 9
        push        1500                                        ; 000005dcH
        push        OFFSET FLAT:$SG581
        call        _printf
        add        esp, 8
; Line 10
        pop        ebp
        ret        0
?printC@@YAXXZ ENDP                                        ; printC
....

push 1500 <- 이라는 부분이 보이실 껍니다. 이게 바로 50 * 30의 결과겠지요? 이게 기계어로 번역되고 링커를 거치면서 실행파일이 만들어지면, #define 에서 했던 곱셈은 이미 없었던 일이 된는 겁니다. ^^;

요샌 프로그램도 못짜고 맨날 파워포인트 작업만 하고 있다보니 손이 근질근질 하군요 ㅜ.ㅜ

첨언하자면

1. 전처리기는 단순 치환만 합니다. (물론 전처리기 연산자들은 - ## 같은 - 내부적으로 처리하지만..)
2. 컴파일러는 구문분석 과정을 통해 실제 코드가 뭘하려는 녀석인지 대충은 알아냅니다. 따라서 최적화 과정을 수행합니다.
3. 링커는 컴파일러에 의해 생성된 obj 파일들을 적절하게 배치하고, PE 프로그램 헤더를 붙여서 실행파일이 되도록 만들어줍니다.

1과 2과정을 거치면서 전처리기에서 선언되었던 것들은 전부 치환/최적화가 됩니다. 치환은 말 그래로 치환이고, 최적화는 상수 * 상수 = 상수이므로 바로 상수를 대입해버린다던가, 쓸데없이 돌아가는 루프가 있다면, 그 루프 자체를 제거해 버린다던가, 캐쉬 히트를 높이기 위해서 구문 자체를 해치지 않는 범위내에서 순서를 뒤 바꾼다던가 등의 작업을 합니다. 말 그대로 최적화 입니다. (최적화도 사이즈를 줄이는 최적화, 속도를 높이는 최적화 두가지가 있습니다.)

3번 과정이야 당연히 실행하려면 다수의 obj 파일들 및 lib 파일들을 하나의 exe나 dll 파일로 만들어서 '실행파일'을 만들어야 하므로, 이 과정을 처리하는 놈입니다.

우와!! snowflower님 bard님 Excelsis님 설명 감사드립니다. 귀에 쏙쏙 들어옵니다 ㅎㅎ 앞으로도 많은 가르침 부탁드립니다!!!

위에서 많은 부분을 설명을 하셨지만, 안쓰신 부분이 있어서 첨가를 합니다.
#define은 쓸때 세심한 주의가 필요한 부분입니다. 모르고 쓰면 엉뚱한 결과값이 나올수도 있기 때문입니다.

만약 다음과 같은 define문을 만들었다고 합시다.
#define MUL(a, b) (a*b)

이것을 사용할때 다음과 같이 쓰면 문제는 없겠지요.
int result = MUL(2,3); // result = 6;

하지만 그냥 함수 쓰듯이 해버리면 어떻게 될까요??
int result = MUL(2+3, 4); // result = ?;

내부적으로 저 부분은 컴파일러가 다음과 같이 치환을 해버립니다.
int result = (2+3*4); // result = 14;

하지만 우리가 원하는 값은 14가 아니라 20이죠. 저것을 막기 위해 #define 구조를 다음과 같이 해야 할 필요가 있습니다.
#define MUL(a, b) ((a)*(b))

각 인자에 기본적으로 ()를 확실히 붙여 우선 계산 순위를 철저히 잡아주는 것입니다. 그럼 컴파일러는 다음과 같이 치환을 해버리죠
int result = ((2+3)*(4)); // OK

#define은 편한 매크로이기도 하지만, 주의해서 쓰지 않으면 오히려 큰코 다칠수 있습니다. 차라리 inline 함수를 쓰는게 더 좋을때도 있죠. 차라리 디버깅 모드에서는 이유라도 알수 있으니깐요.

음 그렇군요. 역시 코드 작성은 쉬운게 없습니다.. orz