[Visual C++] Passare "float" come dati con socket

[DomusP45]

Salve a tutti.

Sto cercando di imparare ad utilizzare le socket per la comunicazione tra due PC. Tutti gli esempi che ho trovato fin'ora, sono tutti di scambio di messaggi tra socket, messaggi di tipo char (con dimensione conosciuta a priori o no).

Ma come si fa a passare dei "float" ad una socket?

Se devo inviare un insieme di dati del tipo

0.0099 0.23344 0.55532 0.00001 0.02223 0.4522 0.2333 0.666 0.00000

come devo fare per fare in modo che dall'altra parte arrivino in quel modo (cioè che sia riconoscibile quando finisce un valore e comincia un altro valore)?

posso usare sempre un buffer "char" per inviare quei valori? Alla fine sono caratteri anche i numeri...solo che non mi è chiaro come fare per distinguere ogni valore dall'altra parte...

[DomusP45]

Originariamente inviato da Antonio23

float sarà sizeof(float) char e double sarà sizeof(double) char...

Ok...grazie della info...

Per utilizzare gli spazi come una sorta di token, sapresti darmi una dritta?

[DomusP45]

Originariamente inviato da Antonio23

puoi utilizzare delle sequenze note di caratteri per comunicare che quelli successivi saranno N float o N double... ma questa è una mia idea magari ci sono funzioni più sofisticate per fare ciò non sono esperto di network programming... e al ricevitore implementare una macchina a stati che riconosca le sequenze di caratteri ricevute..

Ti ringrazio tanto dello spunto...

[WarDuck]

Originariamente inviato da DomusP45

Ok...grazie della info...

Per utilizzare gli spazi come una sorta di token, sapresti darmi una dritta?

Tendenzialmente potresti fare la seguente cosa:

#include <stdint.h>

typedef struct float_buffer_head
{
    int32_t length;
    float data[0];

} float_buffer_head;

Questo sarebbe l'header.

A questo punto lato invio:

int32_t N = 10;

float_buffer_head* my_data = (float_buffer_head*) malloc( sizeof(float_buffer_head) + N*sizeof(float));

my_data->length = N;

// ciclo per riempire my_data->data
...
// invio
send(my_data);

Lato ricevente:

int32_t items = 0;

read(&items, sizeof(int32_t)); // leggi il numero di items dalla socket

// controlla che il numero di items sia valido ...

// alloca la memoria

float_buffer_head* my_data = (float_buffer_head*) malloc( sizeof(float_buffer_head) + items*sizeof(float));

// leggi dalla socket

read(&my_data->data, items*sizeof(float));

ATTENZIONE: il codice seguente NON E' PORTABILE. E' necessario, dal punto di vista dell'endianess delle varie architetture, che gli int e i float vengano convertiti in network byte order e viceversa).

Il codice tuttavia è abbastanza compatto ed efficiente.

E' da un po' che non programmo C puro, quindi non ricordo alcuni dettagli, ad esempio mi pare che non tutti i compilatori C supportano la sintassi:

float data[0];

Ovvero gli array di lunghezza 0, mi pare sia una cosa introdotta in C99. Di fatto è un placeholder per l'array, ed è a tutti gli effetti un puntatore.

La size del campo è 0, quindi se fai sizeof() di una struttura che contiene quel campo ovviamente esso non viene conteggiato.

PS: nota che essendo i float tutti lunghi 4 bytes, non è necessario un delimitatore, è sufficiente leggere 4 bytes alla volta. Se avessi avuto dati di lunghezza variabile (ad esempio stringhe) avresti dovuto fare diversamente.

[DomusP45]

Originariamente inviato da WarDuck

Tendenzialmente potresti fare la seguente cosa:

#include <stdint.h>

typedef struct float_buffer_head
{
    int32_t length;
    float data[0];

} float_buffer_head;

Questo sarebbe l'header.

A questo punto lato invio:

int32_t N = 10;

float_buffer_head* my_data = (float_buffer_head*) malloc( sizeof(float_buffer_head) + N*sizeof(float));

my_data->length = N;

// ciclo per riempire my_data->data
...
// invio
send(my_data);

Lato ricevente:

int32_t items = 0;

read(&items, sizeof(int32_t)); // leggi il numero di items dalla socket

// controlla che il numero di items sia valido ...

// alloca la memoria

float_buffer_head* my_data = (float_buffer_head*) malloc( sizeof(float_buffer_head) + items*sizeof(float));

// leggi dalla socket

read(&my_data->data, items*sizeof(float));

ATTENZIONE: il codice seguente NON E' PORTABILE. E' necessario, dal punto di vista dell'endianess delle varie architetture, che gli int e i float vengano convertiti in network byte order e viceversa).

Il codice tuttavia è abbastanza compatto ed efficiente.

E' da un po' che non programmo C puro, quindi non ricordo alcuni dettagli, ad esempio mi pare che non tutti i compilatori C supportano la sintassi:

float data[0];

Ovvero gli array di lunghezza 0, mi pare sia una cosa introdotta in C99. Di fatto è un placeholder per l'array, ed è a tutti gli effetti un puntatore.

La size del campo è 0, quindi se fai sizeof() di una struttura che contiene quel campo ovviamente esso non viene conteggiato.

PS: nota che essendo i float tutti lunghi 4 bytes, non è necessario un delimitatore, è sufficiente leggere 4 bytes alla volta. Se avessi avuto dati di lunghezza variabile (ad esempio stringhe) avresti dovuto fare diversamente.

Sempre gentilissimo Grazie mille delle dritte

[Tommo]

Originariamente inviato da WarDuck

ATTENZIONE: il codice seguente NON E' PORTABILE. E' necessario, dal punto di vista dell'endianess delle varie architetture, che gli int e i float vengano convertiti in network byte order e viceversa).

Non e' vero, questa cosa ormai e' una "tradizione" che ci si porta dietro ma anzi, NON dovresti farlo IMO.
Intel, ARM, e pure MIPS sono little endian, little endian ha vinto da una buona decina d'anni.
Personalmente, non sprecherei performance e memoria su una cosa che e' del tutto inutile.... butta i dati nel socket cosi' come sono

Allo stesso modo, se tutti i client supportano IEEE 754 (hint: probabilmente si e anche bene) puoi mandare i float cosi' come sono.

[DomusP45]

Originariamente inviato da Tommo

Non e' vero, questa cosa ormai e' una "tradizione" che ci si porta dietro ma anzi, NON dovresti farlo IMO.
Intel, ARM, e pure MIPS sono little endian, little endian ha vinto da una buona decina d'anni.
Personalmente, non sprecherei performance e memoria su una cosa che e' del tutto inutile.... butta i dati nel socket cosi' come sono

Allo stesso modo, se tutti i client supportano IEEE 754 (hint: probabilmente si e anche bene) puoi mandare i float cosi' come sono.

Azz, buono a sapersi allora ....mercoledì sono in laboratorio...faccio la prova subito subito e vi aggiorno...Grazie Tommo anche della tua dritta!

EDIT: Alla fine devo proprio passare una struct via socket...e a quanto pare, funziona tranquillamente.

Grazie a tutti per le dritte.