Newsgroup: it.comp.lang.c
Titolo: Aiuto per uso MACRO

Ciao a tutti, volevo chiedervi se � possibile in ansi C utilizzare una 
macro definita con la classica "#define NOME_MACRO <testo>" per ottenere 
una cosa di questo tipo:
risultato da ottenere una volta "tradotta" la macro:
if( (ch>47)&&(ch<58) )
linea prima che la macro venga "tradotta":
if( CH_IS_DIGIT )
Quindi CH_IS_DIGIT dovrebbe essere una macro che inserisce questo testo: 
(ch>47)&&(ch<58)
E' possibile ottenere un simile risultato? Una semplice #define 
(ch>47)&&(ch<58) non sembra funzionare (certamente un problema � che 
alcuni caratteri sono anche degli operatori che fanno fare delle 
considerazioni collaterali alla #define).
Ci sono delle controindicazioni che sconsigliano l'uso di una macro 
(ammesso che sia possibile ottenere il risultato con una macro) in 
questo caso?
  ciao e grazie anticipatamente per le risposte
-- 
Google Image Labeler cumulative score: 112000

 considerazioni collaterali alla #define).
Hai provato a mettere anche CH_IS_DIGIT nella tua #define? ;)
#define CH_IS_DIGIT (ch>47)&&(ch<58)
Dovrebbe funzionare senza problemi!
ciao
Giacomo

 Google Image Labeler cumulative score: 112000
Come ti hanno già risposto, puoi provare a definire:
#define CH_IS_DIGIT (ch>47) && (ch<58)
ma io semmai farei qualcosa di questo tipo:
#define ISDIGIT(a) ((a)>47 && (a)<58)
e la richiamarei così:
char c = ...;
if (ISDIGIT(c)) {
 // qualcosa qui
}


Scusate, nella scrittura della mail mi ero dimenticato di ricopiare il 
nome della macro dal codice di prova su cui stavo facendo questo 
esperimento. Volevo quindi dire:
"Una semplice #define IS_DIGIT (ch>47)&&(ch<58) non sembra funzionare"


 Dovrebbe funzionare senza problemi!
Questa non è certo la soluzione migliore.
Per un uso più generale io suggerisco
#define IS_DIGIT(CH)  ((CH)>='0'&&(CH)<='9')
Così può essere usata in un test
if (IS_DIGIT(ch)) ......
....
Ciao
Giovanni
-- 
   A computer is like an air conditioner,
   it stops working when you open Windows.
   < 
http://giovanni.homelinux.net/
 >

 if( (ch>47)&&(ch<58) )
Perchè non vuoi usare la funzione standard isdigit() ? 
Non ti piace?
if ( isdigit(ch) ) ...

 if (IS_DIGIT(ch)) ......
Sono d'accordo, ma io preferisco iniziare con la modifica
minima per far funzionare la  soluzione dell'OP, e solo
dopo passo a suggerire le migliorie ! ;)
ciao
Giacomo

 suggerire le migliorie ! ;)
Così non lo aiuti di certo a capire come scrivere le macro.
Come scritta in origne può funzionare in un solo punto del programma. 
  Se il nome della variabile in un punto diverso del programma avesse 
nome diverso non sarebbe più utilizzabile.


<ctype.h>
int isalnum(int c);
isalpha(c) or isdigit(c)
int isalpha(int c);
isupper(c) or islower(c)
int iscntrl(int c);
is control character
int isdigit(int c);
is decimal digit
int isgraph(int c);
is printing character other than space
int islower(int c);
is lower-case letter
int isprint(int c);
is printing character (including space)
int ispunct(int c);
is printing character other than space, letter, digit
int isspace(int c);
is space, formfeed, newline, carriage return, tab, vertical tab
int isupper(int c);
is upper-case letter
int isxdigit(int c);
is hexadecimal digit
int tolower(int c);
return lower-case equivalent
int toupper(int c);
return upper-case equivalent
Notes:
In ASCII (7-bit), printing characters are 0x20 (' ') to 0x7E ('~');
control characters are 0x00 (NUL) to 0x1F (US) and 0x7F (DEL)


Grazie Giovanni! (...e a tutti gli altri).
A basso livello come ï¿œ presumibile che venga convertita questa 
istruzione? Mi spiego meglio: viene inserito del codice macchina tale 
per cui non viene fatta una chiamata a funzione per svolgere il calcolo, 
giusto? Ci sarï¿œ una differenza significativa a livello di codice 
macchina rispetto allo scrivere esplicitamente
if( (ch>47)&&(ch<58) )
?


 istruzione? 
L'uso di una macro non � differente dall'uso del codice esplicito per il
semplice fatto che esiste una fase, nella compilazione di un sorgente C,
che � il preprocessamento. Prima del processamento effettivo da parte del
compilatore, cio�, il preprocessore si spazzola il codice sostituendo le
macro in maniera opportuna. Se scrivo:
#define f(x,y) ((x)+(y))
...
int x = f(5,2);
il preprocessore trasforma il tutto in:
int x = ((5)+(2));
e solo da questo momento in poi parte la compilazione. E' anche per questo
motivo che devi stare attento a porre gli argomenti della macro tra
parentesi nella macro stessa, perch� potresti avere problemi con la
precedenza degli operatori. Per esempio, se scrivessi:
#define f(x,y) x+y
...
int x = f(5,2)*3;
dopo il preprocessamento otterrei:
int x = 5+2*3;
che non � evidentemente quello che desidero. Quindi sarebbe opportuno
scrivere:
#define f(x,y) (x+y)
Ma non basta. E' opportuno porre tra parentesi gli argomenti stessi
nell'espressione della macro, perch� ciascun argomento potrebbe essere
un'espressione, a sua volta:
#define f(x,y) (x*y)
...
int x = f(3+2, 4);
il preprocessore trasforma il tutto in:
int x = (3+2*4);
che non � evidentemente ci� che si vuole. Quindi:
#define f(x,y) ((x)*(y))
in modo che il preprocessore trasformi in:
int x = ((3+2)*(4));
che � corretto. A prescindere da questo caso preciso, � opportuno usare
sempre le parentesi attorno a ciascun parametro delle macro.
-- 
questo articolo e` stato inviato via web dal servizio gratuito 
http://www.newsland.it/news
 segnala gli abusi ad 
ab...@newsland.it

 macro in maniera opportuna
 >
OK, grazie. Avevo il dubbio relativamente alle funzioni macro tipo 
quella proposta da Giovanni ma effettivamente ora intuisco che il 
preprocessore la tradurr� comunque con una normale sostituzione dopo 
aver sostituito il parametro.
