C++: Envoyer un objet via un canal nommé

Question

J'essaie d'envoyer un objet via un canal nommé, entre deux processus, en C++ avec ifstream et ofstream. J'ai lu et essayé tant de choses mais ma recherche n'a abouti à rien.

Je bloque pendant la sérialisation de mon objet. Lorsque j'essaie de lancer et d'envoyer à mon tube nommé, je ne peux pas récupérer mon objet dans son état normal.

J'essaie quelque chose avec ce code, mais l'objet est pas plein après son passage dans le tube nommé:

#include <string.h> 
#include <iostream> 
#include <unistd.h> 
#include <fstream> 
#include <sys/types.h> 
#include <sys/stat.h> 
#include <sys/wait.h> 

class Obj { 
public: 
    std::string text1; 
    std::string text2; 
}; 

int main() { 

    mkfifo("fifo", 0666); 

    if (fork() == 0) //Receiving Side 
    { 

     std::ifstream fifo("fifo", std::ofstream::binary); 

     //Re-make the object 
     Obj *tmp = new Obj(); 
     char *b = new char[sizeof(*tmp)]; 

     //Receive from named pipe 
     fifo >> b; 

     //Recover the object 
     memcpy(&*tmp, b, sizeof(*tmp)); 

     //Display object content 
     std::cout << tmp->text1 << std::endl << tmp->text2 << std::endl; 

     //!\ Output = "Some \n" /!\\ 

     fifo.close(); 
     delete tmp; 
     delete[] b; 
    } 
    else //Sending Side 
    { 
     std::ofstream fifo("fifo", std::ofstream::binary); 

     //Create the object 
     Obj *struct_data = new Obj(); 
     struct_data->text1 = "Some text"; 
     struct_data->text2 = "Some text"; 

     char *b = new char[sizeof(*struct_data)]; 

     //Serialize the object 
     memcpy((void *)b, &*struct_data, sizeof(*struct_data)); 

     //Send to named pipe 
     fifo << b; 

     fifo.close(); 
     wait(NULL); 
     delete[] b; 
    } 

    //delete struct_data; 
    return (0); 
} 

Est-ce que quelqu'un pourrait me donner un pourboire ou en exemple?

Merci! :)

Answer 1

Vous devrez sérialiser correctement votre objet. Quelque chose comme ça (juste fait un membre, le reste sera laissé en excercise au lecteur):

#include <iostream> 
#include <fstream> 
#include <cstring> 
#include <sys/types.h> 
#include <sys/stat.h> 

class Obj 
{ 
    public: 
    std::string text1; 
    std::string text2; 

    friend std::ostream& operator<<(std::ostream &os, const Obj& o); 
    friend std::istream& operator>>(std::istream &os, const Obj& o); 
}; 

std::ostream& operator<<(std::ostream &os, const Obj& o) 
{ 
    os << o.text1.length(); 
    os << o.text1; 
    return os; 
} 
std::istream& operator>>(std::istream &os, Obj& o) 
{ 
    size_t length; 
    os >> length; 
    char* tmp = new char[length]; 
    os.get(tmp, length+1); 
    o.text1 = tmp; 
    delete[] tmp; 
} 

static const char* myfifo = "myfifo"; 

int main(int argc, char *argv[]) 
{ 
    mkfifo(myfifo, 0666); 

    if (argc > 1) 
    { 
    std::ifstream infifo(myfifo, std::ifstream::binary); 

    Obj *tmp = new Obj(); 

    infifo >> *tmp; 
    infifo.close(); 

    std::cout << "Done reading : " << tmp->text1 << std::endl; 
    } 
    else 
    { 
    std::ofstream outfifo(myfifo, std::ofstream::binary); 

    Obj *struct_data = new Obj(); 
    struct_data->text1 = "Some text"; 
    struct_data->text2 = "Some text"; 

    outfifo << *struct_data; 
    } 
    return 0; 
} 

Pour en savoir plus sur la sérialisation voir https://stackoverflow.com/a/26337239/2742863