Memory c语言中的共享内存父和子

大卫·施瓦茨帮了我很多忙，现在它有点起作用了。。。 如果输入包含两个以上需要添加的数字，并且这些数字需要由子级处理，那么您是否有任何想法可以更方便地解析输入？我希望孩子只得到两个整数，这就是为什么我创建了共享内存，所以父亲会将结果（共享内存）+另一个整数发送给孩子

谢谢大家

 #include <sys/types.h>
 #include <sys/ipc.h>
 #include <sys/shm.h>
 #include <string.h>
 #include <signal.h>
 #include <stdio.h>
 #include <stdlib.h>

 volatile int *shared=0;
 int shmid;

 int  main()
 {

 char  line[256];
 int readByte;


 int fd[2]; //pipe to son, who processes addition
 int pid;

 shmid=shmget ( IPC_PRIVATE, sizeof(int) , 0600 );

 shared=shmat ( shmid, 0 , 0);


 if ( pipe(fd) )
 {
   perror("pipe");
   exit(-1);
 }

 pid=fork();

 if (pid!=0) // father
 {
     close (fd[0]);

     readByte=read(0, line, 256);
     line[readByte-1]='\0';
     printf("%d",readByte);

     int arr[2];
     int i=0;
     int j=0;
     int flag=0;
     char num[10];

     while (i<readByte)
     {
         if (line[i]=='+' )
         {
           i++;
           j=0;
           flag=1;
         }

          while (line[i]!='+' && line[i]!='\0')
          {
            num[j]=line[i];
            i++;
            j++;
           }
            num[j]='\0';

       if (flag==0)
           arr[0]=atoi(num);
       else
       {
           arr[1]=atoi(num);
           i++;
       }

     }
       printf("first %d\n",arr[0]);
       printf("sec %d\n",arr[1]);

        write(fd[1], &arr, sizeof(arr));
        wait(NULL);

       printf ( "%d\n" , *shared );

 }
 else
     // son
     {
       int arr[2];
       int sum;

       readByte = read(fd[0], &arr, sizeof(arr));

       printf("son printing: %d\n",arr[0]);
       printf("son printing: %d\n",arr[1]);

       sum =arr[0]+arr[1];
        *shared=sum;

       close (fd[0]);
       shmdt ( (const void *) shared );
     }

 shmdt ( (const void *) shared );
 shmctl ( shmid , IPC_RMID , 0 );

 close(fd[1]);

 return 0;

#包括
#包括
#包括
#包括
#包括
#包括
#包括
volatile int*shared=0；
int shmid；
int main（）
{
字符行[256]；
int读取字节；
int fd[2]；//将管道传递给处理加法的儿子
int-pid；
shmid=shmget（IPC_PRIVATE，sizeof（int），0600）；
共享=shmat（shmid，0，0）；
if（管道（fd））
{
佩罗（“管道”）；
出口（-1）；
}
pid=fork（）；
if（pid！=0）//父
{
关闭（fd[0]）；
readByte=read（0，第256行）；
第[readByte-1]行=“\0”；
printf（“%d”，readByte）；
int-arr[2]；
int i=0；
int j=0；
int标志=0；
字符数[10]；
虽然（i您丢弃了
shmat
的返回值。您希望
shared
被共享，但它只是一个常规变量。此外，您需要防止编译器优化对共享内存的访问。下面是所有致命错误的修复：

#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/shm.h>
#include <string.h>
#include <signal.h>
#include <stdio.h>
#include <stdlib.h>

volatile int *shared;
int shmid;

int main()
{
    int s,i;

    shmid=shmget ( IPC_PRIVATE, sizeof(int), 0600 );

    shared=shmat ( shmid, 0 , 0);
    *shared=100;

    printf ( "%d\n" , *shared);
    if ( fork()==0 ) // son
    {
        *shared=1000;
        shmdt ( (const void *) shared );
    }
    else // father
    {
            wait ( &s );
            printf ( "%d\n" , *shared);
            shmdt ( (const void *) shared );
            shmctl ( shmid , IPC_RMID , 0 );
    }
    return 0;
}

#包括
#包括
#包括
#包括
#包括
#包括
#包括
易失性int*共享；
int shmid；
int main（）
{
int s，i；
shmid=shmget（IPC_PRIVATE，sizeof（int），0600）；
共享=shmat（shmid，0，0）；
*共享=100；
printf（“%d\n”，*共享）；
if（fork（）==0）//son
{
*共享=1000；
shmdt（（常量无效*）共享）；
}
否则//父亲
{
等待（&s）；
printf（“%d\n”，*共享）；
shmdt（（常量无效*）共享）；
shmctl（shmid，IPC_RMID，0）；
}
返回0；
}
变量
shared
不是共享的，共享内存区域是共享的。您需要更改共享内存区域内的某些内容。此外，您还需要丢弃
shmat
的结果，这也没有任何帮助。每个进程都在
fork
之前附加了共享内存段，因此它们都需要在战后将其分离ds。（实际上，当它终止时，'son'将隐式地分离它，因此实际上不需要这样做。）强制转换是为了避免出现关于
volatile
的警告。您的代码中有很多很多bug。我建议您使用调试器分析核心文件，或者在代码中添加大量
printf
语句，以查看它偏离轨道的地方。