Come impedire la funzione dalla stampa?

Question

È possibile eseguire il silenzio? Per esempio:

#include <stdio.h> 
int function(){ 
    printf("BLAH!"); 
    return 10; 

} 
int main(){ 
    printf("%d", silence(function())); 
return 0; 
} 

E invece di:

BLAH! 
10 

avrei ricevuto:

10 

E 'possibile? Se positivo come farlo?

Answer 1

Un modo molto complicato per fare quasi quello che vuoi è utilizzare la chiamata di sistema dup2(). Ciò richiede l'esecuzione di fflush(stdout); dup2(silentfd, stdout); prima della chiamata a function() e la successiva copia: fflush(stdout); dup2(savedstdoutfd, stdout);. Quindi non è possibile fare come solo silence(function()), poiché questo costrutto consente solo di eseguire il codice dopo che function() è già stato eseguito.

I descrittori di file silentfd e savedstdoutfd devono essere preparati in anticipo (codice non testato):

int silentfd = open("/dev/null",O_WRONLY); 
int savedstdoutfd = dup(stdout); 

Questo non è quasi certamente ciò che si vuole veramente, ma nella misura in cui la tua domanda è formulata come “è possibile ? ", La risposta è" quasi ".

Answer 2

Sfortunatamente se si dispone della funzione di stampa esplicita e la si chiama così, verrà sempre stampata. se vuoi disattivare completamente la funzione, puoi semplicemente commentare quella linea. Potresti anche usare un'istruzione di controllo in modo che stampi solo IF e quando viene soddisfatta una condizione, altrimenti rimane vuota e restituisce solo il numero.

Answer 3

Non è possibile. Puoi comunque provare a reindirizzare temporaneamente lo stdout a qualcos'altro. Potrebbe avvicinarsi a quello che vuoi.

Answer 4

È possibile utilizzare questa macro invece di printf per essere in grado di impedire la stampa:

int flag=0; 
#define PRINT(...) if(flag){printf(...)} 

quindi utilizzare STAMPA macro considerando la variabile flag. Se flag==1, la funzione verrà stampata e se flag==0, la funzione non verrà stampata.

Answer 5

utilizza la funzione macro e il dispositivo nullo.

E.g. per le finestre

#include <stdio.h> 

#define silence(x) (_stream = freopen("NUL:", "w", stdout), _ret_value = x,_stream = freopen("CON:", "w", stdout),_ret_value) 
int _ret_value; 
FILE *_stream; 

int function(){ 
    printf("BLAH!"); 
    return 10; 

} 
int main(void){ 
    printf("%d", silence(function())); 
    return 0; 
} 

Answer 6

Se si sta progettando la funzione di eseguire le seguenti operazioni:

int function(void (*printer)(char *)){ 
    if (!printer) 
     printer = printf; 

    printer("BLAH!"); 
    return 10; 
} 

void silence(char *s){ 
    return; 
} 

int main(int argc, char **argv){ 
    printf("%d\n", function(silence)); 
    return 0; 
} 

Questo dovrebbe fare quello che stai cercando. Sfortunatamente, non l'ho provato e la mia C è probabilmente un po 'arrugginita.

Ovviamente se function non è qualcosa su cui si ha il controllo, le risposte già pubblicate sono tutte soluzioni corrette.

---

In realtà, se si sta progettando la funzione da soli, basta fare:

int function(int print){ 
    if (print) 
     printf("BLAH!"); 

    return 10; 
} 


function(0); /* Won't print anything */ 
function(!0); /* Will print "BLAH!" */ 

perché 0 è falso e qualsiasi valore diverso da zero (o !0) è vero. Il mio suggerimento sopra riportato è soggetto ad errori poiché dovrai essere in grado di simulare la firma printf per silence o per qualsiasi altra funzione che desideri utilizzare.

Answer 7

Con GCC extensions, si potrebbe prendere in considerazione che le macro come

bool silent; 
#define silence(X) ({int _x; quiet(); _x = (X); verbose(); _x; }) 
#define printf(Fmt,...) \ 
    do{if (!silent) printf(Fmt,##__VA_ARGS__);}while(0) 

^{che silence macro avrebbe funzionato solo se il suo argomento X è un'espressione int (o usare typeof) Suppongo inoltre che il risultato di printf non è mai Usato. Ricordiamo che le macro "ricorsive" sono appositamente pre-elaborate, l'occorrenza interna di printf (in quella macro printf) è lasciata testualmente senza macroespansione.}

noti che silence non può essere una funzione (in caso contrario, il suo argomento sarebbe stata valutata prima di chiamare). E hai bisogno dell'estensione GCC statement expressions per "ricordare" il risultato dell'argomento in alcune variabili _x (potresti generare quel nome usando __COUNTER__ e la combinazione del preprocessore), per restituirlo come valore della chiamata di macro silence.

allora avete bisogno di definire le funzioni e le quiet()verbose(), forse qualcosa di simile

void quiet() 
{ 
    silent = true; 
} 

void verbose() 
{ 
    silent = false, 
} 

se non si desidera definire printf come la macro, è possibile utilizzare il freopen(3)stdout (magari con "/dev/null" etc. ..) o fare trucchi dup2(2) (come suggested by Pascal Cuoq).

Se la base di codice è enorme, e si desidera qualcosa di più serio e sono disposti a spendere giorni o settimane di lavoro, considerano la personalizzazione del compilatore GCC con un plugin o un'estensione MELT (o chiedere a qualcuno di farlo). Si noti che printf è noto a GCC.

In realtà, si dovrebbe definire il proprio macro come

#define myprintf(Fmt, ...) do{if (!silent) \ 
    printf(Fmt,__VA_ARGS__);}while(0) 

e basta usare myprintf invece di printf ovunque, questo è un trucco portatile. Naturalmente, presumo che non stiate passando a printf come puntatore a funzione.

Per il debug, in realtà ho consiglio

#define dbgprintf(Fmt,...) do{if (wantdebug) \ 
    printf("%s:%d:" Fmt "\n", __FILE__, __LINE__, \ 
      ##__VA_ARGS__);}while(0) 

e poi io uso dbgprintf("i=%d",i) o semplicemente dbgprintf("foo here") nel mio codice.

Sto usando ##__VA_ARGS__ che è un'estensione GCC per accettare no variable arguments in una macro variabile. Se si desidera un C99 rigoroso, si dirà semplicemente __VA_ARGS__ e ogni dbgprintf avrà bisogno di un argomento dopo il formato.

È anche possibile ri-implementare la propria funzione printf, ma non è consigliabile farlo.

(Si noti che le cose potrebbero essere più complesse, è possibile stampare utilizzando fputs non printf ....)