Je vous explique rapidement mon probl=E8me ( en esp=E9rant ne pas =EAtre
trop hors-sujet ).
Je travaille sur des environnements plus ou moins posix ( Linux, *BSD,
MacOSX, Solaris ). J'aimerai envoy=E9 entre diff=E9rentes machines des
informations de type double. Les machines ont =E9videmment des
architectures diff=E9rentes. J'aimerai savoir si il y'a des probl=E9mes
=E0 les envoyer tel quel ( ce que je crains ) et si c'est le cas,
existe-t-il un moyen classique pour encoder / decoder ces doubles pour
que les donn=E9es soient encod=E9es dans un format standard ( comme htons
pour les short par exemple ).
En esp=E9rant avoir =E9t=E9 clair.=20
Merci =E0 tous d'avance.
++
Cette action est irreversible, confirmez la suppression du commentaire ?
Signaler le commentaire
Veuillez sélectionner un problème
Nudité
Violence
Harcèlement
Fraude
Vente illégale
Discours haineux
Terrorisme
Autre
Harpo
wrote:
Bonsoir à tous.
Je vous explique rapidement mon problème ( en espérant ne pas être trop hors-sujet ).
Je travaille sur des environnements plus ou moins posix ( Linux, *BSD, MacOSX, Solaris ). J'aimerai envoyé entre différentes machines des informations de type double. Les machines ont évidemment des architectures différentes. J'aimerai savoir si il y'a des problémes à les envoyer tel quel ( ce que je crains ) et si c'est le cas, existe-t-il un moyen classique pour encoder / decoder ces doubles pour que les données soient encodées dans un format standard ( comme htons pour les short par exemple ).
Le problème avec les standards, c'est leur nombre. Regarde XDR : http://rfc-ref.org/RFC-TEXTS/1832/index.html On doit sans doute trouver des bibliothèques qui l'implémentent.
-- http://harpo.free.fr/
alwe.maindargent@gmail.com wrote:
Bonsoir à tous.
Je vous explique rapidement mon problème ( en espérant ne pas être
trop hors-sujet ).
Je travaille sur des environnements plus ou moins posix ( Linux, *BSD,
MacOSX, Solaris ). J'aimerai envoyé entre différentes machines des
informations de type double. Les machines ont évidemment des
architectures différentes. J'aimerai savoir si il y'a des problémes
à les envoyer tel quel ( ce que je crains ) et si c'est le cas,
existe-t-il un moyen classique pour encoder / decoder ces doubles pour
que les données soient encodées dans un format standard ( comme htons
pour les short par exemple ).
Le problème avec les standards, c'est leur nombre.
Regarde XDR : http://rfc-ref.org/RFC-TEXTS/1832/index.html
On doit sans doute trouver des bibliothèques qui l'implémentent.
Je vous explique rapidement mon problème ( en espérant ne pas être trop hors-sujet ).
Je travaille sur des environnements plus ou moins posix ( Linux, *BSD, MacOSX, Solaris ). J'aimerai envoyé entre différentes machines des informations de type double. Les machines ont évidemment des architectures différentes. J'aimerai savoir si il y'a des problémes à les envoyer tel quel ( ce que je crains ) et si c'est le cas, existe-t-il un moyen classique pour encoder / decoder ces doubles pour que les données soient encodées dans un format standard ( comme htons pour les short par exemple ).
Le problème avec les standards, c'est leur nombre. Regarde XDR : http://rfc-ref.org/RFC-TEXTS/1832/index.html On doit sans doute trouver des bibliothèques qui l'implémentent.
-- http://harpo.free.fr/
Antoine Leca
En news:, es va escriure:
Je travaille sur des environnements plus ou moins posix ( Linux, *BSD, MacOSX, Solaris ). J'aimerai envoyé entre différentes machines des informations de type double.
Passe-les sous forme de nombres ASCII (format style Fortran etc., genre 3.14159E+00 ou 6.02E+23).
Antoine
En news:1137968936.980538.136870@g49g2000cwa.googlegroups.com,
es va escriure:
Je travaille sur des environnements plus ou moins posix ( Linux, *BSD,
MacOSX, Solaris ). J'aimerai envoyé entre différentes machines des
informations de type double.
Passe-les sous forme de nombres ASCII (format style Fortran etc., genre
3.14159E+00 ou 6.02E+23).
Je travaille sur des environnements plus ou moins posix ( Linux, *BSD, MacOSX, Solaris ). J'aimerai envoyé entre différentes machines des informations de type double.
Passe-les sous forme de nombres ASCII (format style Fortran etc., genre 3.14159E+00 ou 6.02E+23).
Antoine
Emmanuel Delahaye
Je vous explique rapidement mon problème ( en espérant ne pas être trop hors-sujet ).
Je travaille sur des environnements plus ou moins posix ( Linux, *BSD, MacOSX, Solaris ). J'aimerai envoyé entre différentes machines des informations de type double. Les machines ont évidemment des architectures différentes. J'aimerai savoir si il y'a des problémes à les envoyer tel quel ( ce que je crains )
Oui, car la représentation interne des nombres (quelque soit le type, à part char) dépend de l'implémentation.
et si c'est le cas, existe-t-il un moyen classique pour encoder / decoder ces doubles pour que les données soient encodées dans un format standard ( comme htons pour les short par exemple ).
Pas à ma connaissance. Le plus simple et le plus standard est le format texte. Sinon, utiliser des formats binaires normalisés comme XDR ou BER.
-- A+
Emmanuel Delahaye
Je vous explique rapidement mon problème ( en espérant ne pas être
trop hors-sujet ).
Je travaille sur des environnements plus ou moins posix ( Linux, *BSD,
MacOSX, Solaris ). J'aimerai envoyé entre différentes machines des
informations de type double. Les machines ont évidemment des
architectures différentes. J'aimerai savoir si il y'a des problémes
à les envoyer tel quel ( ce que je crains )
Oui, car la représentation interne des nombres (quelque soit le type, à
part char) dépend de l'implémentation.
et si c'est le cas,
existe-t-il un moyen classique pour encoder / decoder ces doubles pour
que les données soient encodées dans un format standard ( comme htons
pour les short par exemple ).
Pas à ma connaissance. Le plus simple et le plus standard est le format
texte. Sinon, utiliser des formats binaires normalisés comme XDR ou BER.
Je vous explique rapidement mon problème ( en espérant ne pas être trop hors-sujet ).
Je travaille sur des environnements plus ou moins posix ( Linux, *BSD, MacOSX, Solaris ). J'aimerai envoyé entre différentes machines des informations de type double. Les machines ont évidemment des architectures différentes. J'aimerai savoir si il y'a des problémes à les envoyer tel quel ( ce que je crains )
Oui, car la représentation interne des nombres (quelque soit le type, à part char) dépend de l'implémentation.
et si c'est le cas, existe-t-il un moyen classique pour encoder / decoder ces doubles pour que les données soient encodées dans un format standard ( comme htons pour les short par exemple ).
Pas à ma connaissance. Le plus simple et le plus standard est le format texte. Sinon, utiliser des formats binaires normalisés comme XDR ou BER.
Je vous explique rapidement mon problème ( en espérant ne pas être trop hors-sujet ).
Je travaille sur des environnements plus ou moins posix ( Linux, *BSD, MacOSX, Solaris ). J'aimerai envoyé entre différentes machines des informations de type double. Les machines ont évidemment des architectures différentes. J'aimerai savoir si il y'a des problémes à les envoyer tel quel ( ce que je crains )
Oui, car la représentation interne des nombres (quelque soit le type, à part char) dépend de l'implémentation.
et si c'est le cas, existe-t-il un moyen classique pour encoder / decoder ces doubles pour que les données soient encodées dans un format standard ( comme htons pour les short par exemple ).
Pas à ma connaissance. Le plus simple et le plus standard est le format texte. Sinon, utiliser des formats binaires normalisés comme XDR ou BER.
et pourquoi ne pas utiliser uint32_t htonl (uint32_t hostlong); defini également dans <netinet/in.h>??
Xavier
Emmanuel Delahaye wrote:
Je vous explique rapidement mon problème ( en espérant ne pas être
trop hors-sujet ).
Je travaille sur des environnements plus ou moins posix ( Linux, *BSD,
MacOSX, Solaris ). J'aimerai envoyé entre différentes machines des
informations de type double. Les machines ont évidemment des
architectures différentes. J'aimerai savoir si il y'a des problémes
à les envoyer tel quel ( ce que je crains )
Oui, car la représentation interne des nombres (quelque soit le type, à
part char) dépend de l'implémentation.
et si c'est le cas,
existe-t-il un moyen classique pour encoder / decoder ces doubles pour
que les données soient encodées dans un format standard ( comme htons
pour les short par exemple ).
Pas à ma connaissance. Le plus simple et le plus standard est le format
texte. Sinon, utiliser des formats binaires normalisés comme XDR ou BER.
et pourquoi ne pas utiliser uint32_t htonl (uint32_t hostlong); defini également dans <netinet/in.h>??
Je vous explique rapidement mon problème ( en espérant ne pas être trop hors-sujet ).
Je travaille sur des environnements plus ou moins posix ( Linux, *BSD, MacOSX, Solaris ). J'aimerai envoyé entre différentes machines des informations de type double. Les machines ont évidemment des architectures différentes. J'aimerai savoir si il y'a des problémes à les envoyer tel quel ( ce que je crains )
Oui, car la représentation interne des nombres (quelque soit le type, à part char) dépend de l'implémentation.
et si c'est le cas, existe-t-il un moyen classique pour encoder / decoder ces doubles pour que les données soient encodées dans un format standard ( comme htons pour les short par exemple ).
Pas à ma connaissance. Le plus simple et le plus standard est le format texte. Sinon, utiliser des formats binaires normalisés comme XDR ou BER.
et pourquoi ne pas utiliser uint32_t htonl (uint32_t hostlong); defini également dans <netinet/in.h>??
Xavier
Stéphane Zuckerman
Emmanuel Delahaye wrote:
et si c'est le cas, existe-t-il un moyen classique pour encoder / decoder ces doubles pour que les données soient encodées dans un format standard ( comme htons pour les short par exemple ).
Pas à ma connaissance. Le plus simple et le plus standard est le format texte. Sinon, utiliser des formats binaires normalisés comme XDR ou BER.
et pourquoi ne pas utiliser uint32_t htonl (uint32_t hostlong); defini également dans <netinet/in.h>??
htonl() == solution pour des histoires d'endianness à ma connaissance. Ca ne marche que pour les long ou int, etc. Bref, pour des entiers. L'OP demandait pour un double.
Emmanuel Delahaye wrote:
et si c'est le cas,
existe-t-il un moyen classique pour encoder / decoder ces doubles pour
que les données soient encodées dans un format standard ( comme htons
pour les short par exemple ).
Pas à ma connaissance. Le plus simple et le plus standard est le
format texte. Sinon, utiliser des formats binaires normalisés comme
XDR ou BER.
et pourquoi ne pas utiliser uint32_t htonl (uint32_t hostlong); defini
également dans <netinet/in.h>??
htonl() == solution pour des histoires d'endianness à ma connaissance.
Ca ne marche que pour les long ou int, etc. Bref, pour des entiers. L'OP
demandait pour un double.
et si c'est le cas, existe-t-il un moyen classique pour encoder / decoder ces doubles pour que les données soient encodées dans un format standard ( comme htons pour les short par exemple ).
Pas à ma connaissance. Le plus simple et le plus standard est le format texte. Sinon, utiliser des formats binaires normalisés comme XDR ou BER.
et pourquoi ne pas utiliser uint32_t htonl (uint32_t hostlong); defini également dans <netinet/in.h>??
htonl() == solution pour des histoires d'endianness à ma connaissance. Ca ne marche que pour les long ou int, etc. Bref, pour des entiers. L'OP demandait pour un double.
Emmanuel Delahaye
et si c'est le cas, existe-t-il un moyen classique pour encoder / decoder ces doubles pour que les données soient encodées dans un format standard ( comme htons pour les short par exemple ).
et pourquoi ne pas utiliser uint32_t htonl (uint32_t hostlong); defini également dans <netinet/in.h>??
Pour les doubles ? Ca va être intéressant...
-- A+
Emmanuel Delahaye
et si c'est le cas,
existe-t-il un moyen classique pour encoder / decoder ces doubles pour
que les données soient encodées dans un format standard ( comme htons
pour les short par exemple ).
et pourquoi ne pas utiliser uint32_t htonl (uint32_t hostlong); defini
également dans <netinet/in.h>??
et si c'est le cas, existe-t-il un moyen classique pour encoder / decoder ces doubles pour que les données soient encodées dans un format standard ( comme htons pour les short par exemple ).
et pourquoi ne pas utiliser uint32_t htonl (uint32_t hostlong); defini également dans <netinet/in.h>??
Pour les doubles ? Ca va être intéressant...
-- A+
Emmanuel Delahaye
Danious
effectivement htonl marche pas pour les doubles et de toute facon l'utilisation de htons et htonl est vraiment contraignante parfois.
A mon avis, la solution d' Emmanuel Delahaye doit etre la meilleure : le format texte.
A+
effectivement htonl marche pas pour les doubles et de toute facon
l'utilisation de htons et htonl est vraiment contraignante parfois.
A mon avis, la solution d' Emmanuel Delahaye doit etre la meilleure :
le format texte.
effectivement htonl marche pas pour les doubles et de toute facon l'utilisation de htons et htonl est vraiment contraignante parfois.
A mon avis, la solution d' Emmanuel Delahaye doit etre la meilleure : le format texte.
A+
David Bertolo
a écrit dans le message de news: Bonsoir à tous.
Je vous explique rapidement mon problème ( en espérant ne pas être trop hors-sujet ).
Je travaille sur des environnements plus ou moins posix ( Linux, *BSD, MacOSX, Solaris ). J'aimerai envoyé entre différentes machines des informations de type double. Les machines ont évidemment des architectures différentes. J'aimerai savoir si il y'a des problémes à les envoyer tel quel ( ce que je crains ) et si c'est le cas, existe-t-il un moyen classique pour encoder / decoder ces doubles pour que les données soient encodées dans un format standard ( comme htons pour les short par exemple ).
En espérant avoir été clair. Merci à tous d'avance. ++
-- Arnaud
De mémoire, il me semble que ASN1 sert justement à ça. David
<alwe.maindargent@gmail.com> a écrit dans le message de
news:1137968936.980538.136870@g49g2000cwa.googlegroups.com...
Bonsoir à tous.
Je vous explique rapidement mon problème ( en espérant ne pas être
trop hors-sujet ).
Je travaille sur des environnements plus ou moins posix ( Linux, *BSD,
MacOSX, Solaris ). J'aimerai envoyé entre différentes machines des
informations de type double. Les machines ont évidemment des
architectures différentes. J'aimerai savoir si il y'a des problémes
à les envoyer tel quel ( ce que je crains ) et si c'est le cas,
existe-t-il un moyen classique pour encoder / decoder ces doubles pour
que les données soient encodées dans un format standard ( comme htons
pour les short par exemple ).
En espérant avoir été clair.
Merci à tous d'avance.
++
--
Arnaud
De mémoire, il me semble que ASN1 sert justement à ça.
David
Je vous explique rapidement mon problème ( en espérant ne pas être trop hors-sujet ).
Je travaille sur des environnements plus ou moins posix ( Linux, *BSD, MacOSX, Solaris ). J'aimerai envoyé entre différentes machines des informations de type double. Les machines ont évidemment des architectures différentes. J'aimerai savoir si il y'a des problémes à les envoyer tel quel ( ce que je crains ) et si c'est le cas, existe-t-il un moyen classique pour encoder / decoder ces doubles pour que les données soient encodées dans un format standard ( comme htons pour les short par exemple ).
En espérant avoir été clair. Merci à tous d'avance. ++
-- Arnaud
De mémoire, il me semble que ASN1 sert justement à ça. David
Emmanuel Delahaye
De mémoire, il me semble que ASN1 sert justement à ça.
ASN-1 n'est qu'une norme de spécification. Pour l'implémentation, on utilise, par exemple, BER (Basic Encoding Rules). C'est pas vraiment trivial comme codage...
-- A+
Emmanuel Delahaye
De mémoire, il me semble que ASN1 sert justement à ça.
ASN-1 n'est qu'une norme de spécification. Pour l'implémentation, on
utilise, par exemple, BER (Basic Encoding Rules). C'est pas vraiment
trivial comme codage...
De mémoire, il me semble que ASN1 sert justement à ça.
ASN-1 n'est qu'une norme de spécification. Pour l'implémentation, on utilise, par exemple, BER (Basic Encoding Rules). C'est pas vraiment trivial comme codage...
