Java Process Bogue InputStream?

Question

Salut les gars. Donc, voici l'affaire. J'ai un programme Java qui exécute un programme C++. Le processus C++ envoie des doubles au programme Java en appelant simplement write sur std :: cout avec un cast de pointeur. Le programme Java utilise getInputStream de Process(), lit 8 octets et les convertit en double en utilisant un décalage d'octets et Double.longBitsToDouble(). Je me suis assuré que les tailles de caractères ainsi que les ordres d'octets correspondent entre les deux applications. Maintenant, bien que cela fonctionne la plupart du temps, une erreur se produit souvent.

J'ai isolé l'une des erreurs sur une simple séquence d'octets que je semble incapable de transférer correctement. Consultez les extraits suivants:

#include <iostream> 

int main(int argc, char** argv) { 
    long long l = 0x4048e398b90ae1b6; 
    char* ptr = (char*) &l; 
    std::cout.write(ptr, 8); 
    std::cout.flush(); 


    // for (int i = 0; i < 8; ++i) 
    // std::cout.put(ptr[i]); 
    // std::cout.flush() 
} 

Et l'application Java:

public static void main(String[] argv) throws IOException { 
    Process p = Runtime.getRuntime().exec("prog.exe"); 
    InputStream is = p.getInputStream(); 

    for (int i = 0 ; i < 8; ++i) { 
    System.err.print(Long.toHexString(is.read()) + " "); 
    } 
} 

Ce sont des exemples assez simples mais ils serveur pour démontrer mon problème. Quand je cours ceci sur ma machine de Windows 7. Je reçois la sortie Java suivante:

b6 e1 d a b9 98 e3 48 

Le résultat attendu est

b6 e1 a b9 98 e3 48 40 

D'une certaine façon, un octet 0x0D supplémentaire est inséré. Cependant, ce qui est vraiment étrange est que si à l'intérieur de l'application java on peut lire un octet (changer le 8 à 9), nous obtenons

b6 e1 d a b9 98 e3 48 40 

Cela signifie que le InputStream contenait en fait 9 octets de données et une fois que extra 0x0d est supprimé il contient les données correctes.

Qu'en pensez-vous? Comme je l'ai déjà mentionné, cela n'arrive pas souvent, mais quand c'est le cas, c'est désastreux.

Merci à l'avance, zienkikk

Answer 1

cout est par défaut ouvert en mode texte, ce que je dirais qui se passe est que le caractère 0xa (saut de ligne) est de se converti en une séquence <CRLF> au cours pré-traitement de sortie.

Je ne pense pas qu'il soit possible d'écrire de manière fiable des données binaires à cout (voir here par exemple), donc je convertirais la sortie désirée en texte, et désérialiserais du côté de l'entrée (Java).

Answer 2

Il me semble que votre shell Windows convertit le terminateur de ligne de style UNIX LF (0xA) en CRLF Windows Line Terminator (0xD OxA).

Généralement, il n'est pas recommandé d'écrire des données binaires dans le flux de sortie du programme pour cette raison particulière. Convertissez vos données longues en texte, puis analysez-les du côté Java.

Answer 3

C++ traduit 0x0A, qui est \ n, en 0x0d0a, qui est \ r \ n. Il y a une méthode pour l'arrêter, ne peut pas vous aider avec ce que c'est. Je n'utiliserais pas iostreams pour les données binaires moi-même, j'utiliserais probablement juste write() ou fwrite().