C++ 如何通过fifo发送结构 你好

我试图从一个程序中传递整个结构，并使用fifo在另一个程序中读取它。 我正在使用读写函数

我在将我的结构放入这个函数时遇到了问题。当我这样做，并试图发送和接收我得到一个错误（核心转储）或我收到一些垃圾。我不知道我的问题具体发生在哪里（收件人或发件人）。我如何发送/接收我的结构，或者我的代码中有什么错误。这是我的代码…

接收器

struct data
{
    char* message;
    int size;
    vector <times> prog;
};

int if_fifo(char* name)
{
    struct stat info;
    int score = stat(name,&info);
    if(S_ISFIFO(info.st_mode))
    {
        return 1;
    }
    else
    {
        return 0;
    }
}

int fifo_in(char* name)
{
    data msg;
    int pip;
    pip = open(name, O_RDONLY | O_NONBLOCK);
    while(1)
    {
        int hr = read(pip,&msg,sizeof(msg));
        if(hr != 0)
        {
            cout << "Message:   " << msg.message << endl;
        }
    }
    cout << "O.K." << endl;
    return 0;
}

int main(int argc, char** argv) {
int c, status_in, status_out;
char* input;
char* output;
float del;

if(argc < 5)
{
    cout << "Za malo podanych parametrow" << endl;
    return 1;
}
else
{
    while ((c = getopt(argc, argv, "iod:")) != -1)
    {
        switch (c)
        {
        case 'i':
            input = argv[2];
            status_in = if_fifo(input);
            break;
        case 'o':
            output = argv[3];
            status_out = if_fifo(output);
            break;
        case 'd':
            del = atof(argv[4]);
            break;
        case '?':
            printf("UKNOWN");
        }
    }
}

if(status_in == 1)
{
    return fifo_in(input);
}
else
{
    cout << "It isnt fifo!!" << endl;
}

return 0;
}

struct数据
{
字符*消息；
整数大小；
矢量程序；
};
int if_fifo（字符*名称）
{
结构统计信息；
int score=stat（名称和信息）；
if（S_ISFIFO（信息存储模式））
{
返回1；
}
其他的
{
返回0；
}
}
int fifo_输入（字符*名称）
{
数据消息；
int-pip；
pip=打开（名称，仅O|u RDONLY | O|u NONBLOCK）；
而(1)
{
int hr=read（pip，&msg，sizeof（msg））；
如果（hr！=0）
{
cout你不能只将内存结构从一个程序发送到另一个程序。你必须做所谓的“序列化”，即将结构转换成表示该结构的字节流。有很多很多序列化技术：ASN1/Ber、XML、JSON、Google protocol buff，你自己动手吧

让您知道原因。结构中的字段消息实际上是一个指针，当您将此指针发送到另一个程序时，它指向相同的地址，但在接收方程序中不是发送方。该地址可能不存在，并且肯定不包含发送方程序中的字符串。
您不能只发送内存从一个程序到另一个程序的结构。你必须做所谓的“序列化”，即将结构转换为表示结构的字节流。有很多很多序列化技术：ASN1/Ber、XML、JSON、谷歌协议爱好者，你自己动手

让您知道原因。结构中的字段消息实际上是一个指针，当您将此指针发送到另一个程序时，它指向相同的地址，但在接收方程序中不是发送方。该地址可能不存在，并且肯定不包含发送方程序中的字符串。
您不能只发送内存从一个程序到另一个程序的结构。你必须做所谓的“序列化”，即将结构转换为表示结构的字节流。有很多很多序列化技术：ASN1/Ber、XML、JSON、谷歌协议爱好者，你自己动手

让您知道原因。结构中的字段消息实际上是一个指针，当您将此指针发送到另一个程序时，它指向相同的地址，但在接收方程序中不是发送方。该地址可能不存在，并且肯定不包含发送方程序中的字符串。
您不能只发送内存从一个程序到另一个程序的结构。你必须做所谓的“序列化”，即将结构转换为表示结构的字节流。有很多很多序列化技术：ASN1/Ber、XML、JSON、谷歌协议爱好者，你自己动手

让您知道这是为什么。结构中的字段消息实际上是一个指针，当您将此指针发送到另一个程序时，它指向相同的地址，但在接收方程序中不是发送方。该地址可能不存在，并且肯定不包含发送方程序中的字符串。
这是太多的代码，无法查看粗略。有关编写好问题的提示，请参阅。代码太多，无法查看。有关编写好问题的提示，请参阅。代码太多，无法查看。有关编写好问题的提示，请参阅。代码太多，无法查看。有关编写好问题的提示，请参阅。
struct data
{
    char* message;
    int size;
    vector <times> prog;
}msg;

int if_fifo(char* name)
{
    struct stat info;
    int score = stat(name,&info);
    if(S_ISFIFO(info.st_mode))
    {
        return 1;
    }
    else
    {
        return 0;
    }
}

int fifo_out(char* name)
{
    msg.message = "To jest to!!";
    msg.size = sizeof(msg.message);
    int pip;
    pip = open(name, O_WRONLY);
    if(  pip == -1 )
    {
        perror("Error: open( ): ");
        return 1;
    }
    write(pip,&msg,sizeof(msg));
    return 0;
}

int main(int argc, char** argv) {
    int c, status_out;
    char* output;

    if(argc < 3)
    {
        cout << "Za malo podanych parametrow" << endl;
        return 1;
    }
    else
    {
        while ((c = getopt(argc, argv, "o:")) != -1)
        {
            switch (c)
            {
                case 'o':
                    output = argv[2];
                    status_out = if_fifo(output);
                    break;
                case '?':
                    printf("UKNOWN");
            }
        }
    }

    if(status_out == 1)
    {
        return fifo_out(output);
    }   
    return 0;
}