C++: Ein Objekt über eine Named Pipe senden

Question

Ich versuche, ein Objekt über eine Named Pipe zwischen zwei Prozessen in C++ mit ifstream und ofstream zu senden. Ich habe so viele Dinge gelesen und probiert, aber meine Forschung hat zu nichts geführt.

Ich blockiere während der Serialisierung meines Objekts. Wenn ich versuche, an meine Named Pipe zu senden und zu senden, kann ich mein Objekt nicht in seinem normalen Zustand wiederherstellen.

ich versuche, etwas mit diesem Code aber das Objekt ist nach seinem Durchgang in dem Named Pipes nicht voll:

#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); 
} 

Was mir jemand könnte einen Tipp geben oder en Beispiel?

Danke! :)

Answer 1

Sie müssen Ihr Objekt ordnungsgemäß serialisieren. So etwas wie dies (tat nur ein Mitglied, der Rest wird als Übung dem Leser überlassen werden):

#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; 
} 

Weitere Informationen über die Serialisierung https://stackoverflow.com/a/26337239/2742863