Newsgroup: it.comp.lang.c
Titolo: Convertire un intero in una Stringa

Scusate la domanda, forse un po' idiota, ma come faccio a convertire un 
intero in una stringa?
Devo scrivere un intero su una socket, ma tutte le primitive di scrittura 
richiedono come parametro di ingresso  "const char *buff".
Grazie a tutti.
Ciao
ValerioZ

 intero in una stringa?
int a;
char buffer[10];
a = 10;
sprintf(buffer, "%d", a);

Paolo Podda <p.p...@tiscaliNOSPAM.it> wrote in 
news:3656476.b...@news.iol.it
:

Grazie mille.
ValerioZ

 wrote

Non e' indispensabile convertirlo in stringa (e poi magari riconvertirlo in
numero successivamente nell'altro PC, tempo sprecato!(e bytes sprecati se il
numero e' lungo!)).
L'idea che si spediscano dei "const char *buff" e' che si spedisce un buffer
di BYTES (un char occupa un byte).
Non e' importante che essi siano realmente char!!!! Potrebbe essere ad
esempio un INT32 spedito come 4 char oppure anche una struttura!
Ok, diciamo per esempio che hai :
int n=7891230;
bene, esistono computers big_endians e little_endians e quindi perche'
questi possano comunicare devi prima chiamare
htonl che converte un host long in un network long e successivamente, sulla
macchina che riceve, ntohl che converte un network long in un host long.
Questo processo garantisce che il numero che inizialmente e' 7891230 arrivi
come 7891230 !!!
(nota che su machine con la stessa architettura non e' indispensabile, ma e'
cmq buona pratica per rendere codice portabile!)
network_n=htonl(n);
(e sul mio PC network_n diventa: 510228480, nota che alcune macchine leggono
questo numero come 7891230 visto il diverso byte order.)***
A questo punto potresti spedire network_n!
Come?!?
sizeof() ritorna la dimensione in bytes del tipo scelto, in questo caso 4:
send(s,(char*)&network_n,sizeof(int),0);
Ok, in questo modo spedisci sul socket s 4bytes, partendo dal primo byte di
network_n.
Altrimenti se preferisci puoi avere un char buff[4] e poi copiare i quattro
bytes dell'intero dentro tale buffer e poi spedire il buffer. Questo e' piu'
utile se vuoi fare cose miste tipo:
char buff[1050];    // grande buffer!
// Composizione del grande buffer: //
// 1000 corpo del messaggio
// 4 intero che corrisponde al codice utente del mittente
// 4 intero che corrisponde al codice utente del destinatario
// 4 intero che corrisponde all'orario di spedizione
// 1 char che corrisponde al codice di priorita'
// 32 oggetto del messaggio
// 5 riservati per uso futuro
[questo esempio e' per una BANALE e NON reale buffer per programmi di
instant messaging tipo ICQ!]
In questo modo potresti riempire il buffer di bytes ed una volta riempito
(con interi, char, stringhe etc...) spedirlo!
Il buffer contiene varie cose in una volta sola e chi lo riceve deve sapere
come e' composto ed usarne le varie parti!
Gli interi devo essere riscritti all'interno di variabili intere grazie
anche all'ausilio di ntohl !
Anche in questo modo non importa fare "sprintf(buffer, "%d", a);" e
convertire il numero in stringa, ma lo si puo' tenere come interno
all'interno di un buffer di bytes (dove in C un byte non esiste e si usa
char!).
Cio' che e' sbagliato nel convertirlo in stringa e' che la lunghezza diventa
variabile, ad esempio 9 occupa 1 char, mentre 1000000000 occupa 10 char! Se
lo lasci come int occupa sempre 4 chars (beh, bytes!).
In questo modo e' piu facile definire un "protocollo" come quello presentato
per ICQ-Like. Infatti tale "protocollo" si basa sul fatto che ogni campo ha
una lunghezza fissa e quindi sai che dalla posizione 1000 alla 1003 trovi
l'intero che corrisponde al codice del mittente!
Per concludere con:
send(s,(char*)&network_n,sizeof(int),0);
puoi spedire solo una cosa!
Se riscrivi l'intero all'interno di un buffer puoi spedire piu' cose
contemporaneamente!
Ad ogni modo evita di convertirlo in stringa almeno che non sia quello che
vuoi.
Ciao,
Tommy
** Sulle macchine little-endian le due funzioni fanno il loro compito. Sulle
macchine big-endian le due funzioni non fanno nulla visto che il network
byte order e' lo stesso del host byte order!!!

 wrote
[...]
Bene, volevo darti un esempio di come scrivere all'inerno di un buffer
misto:
<CODE>
#include<stdio.h>
#include<stdlib.h>
#include<winsock2.h>
int main()
{
     long n=7891230;
     long network_n;
     char buff[16]; // intero deve stare dal 4 al 7!
     // parte di coului che spedisce!
     network_n=htonl(n); // ora e' pronto per la rete!
     *((int*)(&buff[3]))=network_n;
     /****************************/
     /* SPEDISCE IN QUALCHE MODO */
     /****************************/
     //---------------------------------------------
     // parte di colui che riceve!
     /****************************/
     /* RICEVE IN QUALCHE MODO   */
     /****************************/
     network_n=*((int*)(&buff[3]));
     n=ntohl(network_n);
     printf("Il numero ricevuto e':%d\n",n);
     return 0;
}
</CODE>
E l'output ovviamente e' :
<OUTPUT>
Il numero ricevuto e':7891230
Press any key to continue
</OUTPUT>
Il programma presentato e' diviso in due parti:
- la prima e' quello che spedisce, prende un  numero, e lo scrive in un
buffer.
- la seconda riceve il buffer e ne estrae il numero per poi stamparlo a
video.
NOTA che il numero arriva come intero e NON come stringa.
Essendo un unico programma e non avendo alcun socket il buffer non viene
spedito ovviamente.
Questo e' solo un esempio! La seconda parte si limita a riutilizzare il
buffer (per leggere) e riutilizzare le variabili per scriverci sopra cio'
che stava nel buffer!
Spero ti possa essere di aiuto.
Tommy

 
Sei stato di grandissimo aiuto.
Grazie 1000.
Ciao
ValerioZ