Newsgroup: it.comp.lang.c
Titolo: Aiuto con #define

Ciao a tutti,
ho una define di questo tipo:
#define NUM 0x30
Devo definire, sempre mediante #define, una stringa che contiene
una prima parte letterale ed una seconda parte numerica. Del tipo:
#define STRINGA "Numero:x"
dove x non č un carattere ma un byte che numericamente vale 30 nel
mio esempio.
Potrei scrivere:
#define STRINGA "Numero:\x30"
ma in questo caso dovrei modificare il numero 0x30 sia nella #define
NUM che nella #define STRINGA. C'č un modo per definire 0x30 solo
una volta ed integrarlo, come byte numerico, all'interno di una
stringa, a livello di compilazione e non in runtime?
Sarebbe anche bello poter definire il numero in decimale, chiedo
troppo?

 mio esempio.
Io non ho capito cosa vuol dire.

 #define STRINGA "Numero:x"
Per quel che ne so, il massimo che si puo' fare a livello di macro e':
#define NUM  "\x30"
#define STRINGA  "Numero " ## NUM
Occhio che cosi' NUM e' una stringa.
Ciao

 ha scritto nel messaggio
news:%hAhc.18297$eR5....@tornado.fastwebnet.it...

Ti spiego... una stringa in C non è altro che una sequenza di caratteri,
tutto sommato dei byte che hanno un range 0..255.
Molti di questi valori rappresentano in ASCII dei caratteri stampabili
(le lettere alfabetiche, le cifre, i segni di punteggiatura, ecc.) e,
normalmente, una stringa è formata da una sequenza di caratteri ASCII.
In alcuni casi, però, può essere utile inserire in una sequenza dei
caratteri, dei byte che non hanno una corrispondenza precisa nella tabella
ASCII, ma sono dei byte e basta (naturalmente, la visualizzazione di una
stringa con questo tipo di caratteri non è garantita e dipende sicuramente
dal sistema operativo).
In C è possibile definire delle stringhe costanti che contengono dei byte
"qualsiasi" nel modo seguente:
    "Questo è un byte: \x33"
oppure
    "Questo è un byte: \033"
Nel primo caso l'ultimo byte della stringa (prima del null-character) è
0x33, mentre nel secondo caso è 33 in ottale.
Bene, io voglio definire una stringa simile, dove, però, il numero da
accodare alla stringa è definito mediante define.
Cioè, invece di scrivere:
    #define    STRINGA    "Questo è un byte: \x33"
vorrei scrivere:
    #define    NUM        0x33
    #define    STRINGA    ??????
dove devo sostituire ai ????? una espressione del preprocessore che
mi consenta di avere la stringa costante "Questo è un byte: \x33".

 ha scritto nel messaggio
news:7PAhc.121446$rM4.4...@news4.tin.it...

Ci avevo pensato, però NUM mi serve anche come numero e non solo come
stringa. Dovrei, in questo caso, definire un simbolo NUM numerico e NUM
stringa, ma vorrei evitare la doppia #define.

 troppo?
#define NUM 48

> troppo?
Anche qua avevo frainteso: no, puoi esprimere le costanti tra apici in 
modo numerico solo in ottale o esadecimale. Puoi comunque eliminare gli 
apici e scriverle in decimale. Le due istruzioni seguenti sono equivalenti:
char c = '\x30';
char c = 48;
...come anche:
#define NUM '\x30'
#define NUM 48

   * stringa delimitate da doppi apici. */
E' una soluzione, anche se molto brutta. La stringa è molto lunga, non
quella che ho scritto come esempio. Sai che bello scriverla carattere
per carattere!

 per carattere!
Lo so. Il problema e` che stiamo cercando di usare il preprocessore per 
qualcosa che non e` in grado di fare, e il risultato e` quindi terribile.
Ma devi *per forza* usare solo il preprocessore? O ti basta definire NUM 
una sola volta e si puo` generare la stringa in altro modo?

 ha scritto nel messaggio
news:408A3A9B...@lombardiacom.it...

Certo che potrei usare una istruzione a run-time per inserire un byte in
una stringa, il problema è che la stringa in definitiva è costante, quindi
perché "sprecare" una istruzione per questo? Tra l'altro, il programma è
per microcontrollore, dove molto spazio per il codice non c'è.