Помогите пожалуйста с дефайном (+)

книжку почитать, что же ещё :)

#ifdef DEBUG
write_log("num err\n");
#endif

типа того.

Если проект поддерживается с помощью autotools, то там в configure даже есть специальная опция --enable-debug

Такой способ я знаю
но это совсем не то, это придется еще большую работу сделать
по вставлении #ifdef\#endif в код, и впридачу
это сильно заграмоздит код, ухудшая его вид и читабельность
я хочу сделать дефайн именно самой функции write_log
по хитрому, и знаю что это возможно, но не могу найти как...

можно объявлять макросы с параметрами:

#ifdef DEBUG
# define log(s) printf("%s",s)
#else
# define log(s)
#endif

если ты выводиь тольк строки, то делай как сказал ID19999. Если в функцию передаётся непостоянное кол-во параметров (var args), то как можно было бы догадаться (!) эта фукция должна выглядеть как

void write_log(...)
{
#ifdef DEBUG

/* нужные дейсвия */

#endif
}

Да, забыл сказать, количество параметров не постоянно :)
А дефайном никак ?
Т.к. вызов функции это уже затраты ресурсов
или компилер если там будет
void write_log(...)
{
return;
}
оптимизирует чтоб реально вызова небыло ?

Если проект строится gcc, тогда можно воспользоватся следующим приемом:

#define PDEBUG(fmt, args...) fprintf(stderr, fmt, ## args)

При вызове макро PDEBUG аргументы будут переданы fprintf - или же иной функции с переменным количеством параметров.

Подробнее можно прочитать тут:
http://www.ugrad.physics.mcgill.ca/reference/Cpp/cpp_1.html#SEC17

Переносимый вариант:

#define LOG_DEBUG(x) do { \
log_printf("%s:%d: ", __FILE__, __LINE__); \
log_printf x; \
} while (0)

Только используется "особым" образом:

LOG_DEBUG(("one %d two %d", 1, 2));

Честно говоря, не вижу проблемы.

Вот примерно так это может выглядеть в RELEASE

#define write_log(P1) 
#define write_log((P1),(P2))
#define write_log((P1),(P2),(P3))
#define write_log((P1),(P2),(P3),(P4))
/* если нужно дальше, то компилятор подскажет */

и так в DEBUG

int write_log(char *s, ...)
{
    va_start
    /* ... */
}

Честно говоря, не вижу проблемы.

Вот примерно так это может выглядеть в RELEASE

#define write_log(P1) #define write_log((P1),(P2)) #define write_log((P1),(P2),(P3)) #define write_log((P1),(P2),(P3),(P4)) /* если нужно дальше, то компилятор подскажет */

и так в DEBUG

int write_log(char *s, ...) { va_start /* ... */ }

это так, про переменное число аргументов..
#ifdef DEBUG
#define log(msg,...) { \
 fprintf(stderr,"%s:%d ",__FILE__,__LINE__); \
 fprintf(stderr,msg,##__VA_ARGS__); \
 fputc('\n',stderr); \
 fflush(stderr); \
}
#else
#define log(msg,...) ;
#endif
в текстах ядра linux встечается встречается вместо обрамляющих {}
конструкция do { something } while(0) , что тоже имеет смысл

>>Т.к. вызов функции это уже затраты ресурсов

вызов функции - разве это большие затраты ресурсов ?? :)

>>оптимизирует чтоб реально вызова небыло ?

Ты  не понимаешь смысла препроцессорных директив. Они потому и называются ПРЕпроцессорные.

Если DEBUG определён, но твоя функция

void write_log(...)
{
#ifdef DEBUG

   /*  что-то сделать */

#endif
}

ПЕРЕД самой компиляцией

будет выглядеть

void write_log(...)
{
   /*  что-то сделать */
}

иначе

void write_log(...)
{
}

-------------------------------------------------------

Понял ? Ради понимания процесса можешь написать тест:
$ gcc -o 19 -DDEBUG 19.c
$ ./19
HO-HO-HO
$ gcc -o 19 19.c
$ ./19
$
$ cat 19.c
#include <stdio.h>

void write_log()
{
#ifdef DEBUG

    fprintf(stderr, "HO-HO-HO\n");

#endif
}

int main(int argc, char **argv)
{
    write_log();

    return 0;
}
$

А теперь самое интересное, ассемблер:

$ gcc -S -DDEBUG 19.c
$ cat 19.s
        .file   "19.c"
        .section        .rodata
.LC0:
        .string "HO-HO-HO\n"
        .text
.globl write_log
        .type   write_log, @function
write_log:
        pushl   %ebp
        movl    %esp, %ebp
        subl    $8, %esp
        subl    $8, %esp
        pushl   $.LC0
        pushl   stderr
        call    fprintf
        addl    $16, %esp
        leave
        ret
        .size   write_log, .-write_log
.globl main
        .type   main, @function
main:
        pushl   %ebp
        movl    %esp, %ebp
        subl    $8, %esp
        andl    $-16, %esp
        movl    $0, %eax
        subl    %eax, %esp
        call    write_log
        movl    $0, %eax
        leave
        ret
        .size   main, .-main
        .section        .note.GNU-stack,"",@progbits
        .ident  "GCC: (GNU) 3.3.2 (Mandrake Linux 10.0 3.3.2-6mdk)"

И втрой вариант, без DEBUG:
$ gcc -S 19.c
$ cat 19.s
        .file   "19.c"
        .text
.globl write_log
        .type   write_log, @function
write_log:
        pushl   %ebp
        movl    %esp, %ebp
        popl    %ebp
        ret
        .size   write_log, .-write_log
.globl main
        .type   main, @function
main:
        pushl   %ebp
        movl    %esp, %ebp
        subl    $8, %esp
        andl    $-16, %esp
        movl    $0, %eax
        subl    %eax, %esp
        call    write_log
        movl    $0, %eax
        leave
        ret
        .size   main, .-main
        .section        .note.GNU-stack,"",@progbits
        .ident  "GCC: (GNU) 3.3.2 (Mandrake Linux 10.0 3.3.2-6mdk)"

--------------------------------------------------------------------------------
------

Надеюсь, всё видно.