增加管道输出的大小（以c+为单位）+； 我编写了一个C++代码，实现父和子处理器之间的双向管道。 一切都很好，我只需要增加缓冲区的大小（管道的输出）。我知道有很多帖子都使用malloc来处理char的大小，但我认为我的问题有点具体，因为它需要以下内容： 确定从管道返回的缓冲区（字符数组）的大小 将缓冲区的大小增加到大于1 MB的大小

以下是我的代码片段：

#define PARENT_READ readpipe[0]
#define CHILD_WRITE readpipe[1]
#define CHILD_READ writepipe[0]
#define PARENT_WRITE writepipe[1]

 int writepipe[2] = {-1,-1};// parent -> child                                                                                                                                                          
 int readpipe[2] = {-1,-1};//child -> parent                                                                                                                                                            
 pid_t childpid;                                                                                                                                                                              
 string pipeInput;
 const char * c;
 **char buffer [1000000]; //1 MB for now ..**  

if((childpid=fork())<0)
   {
      //cannot fork child                                                                                                                                                                                
      printf("cannot fork child");
      exit(-1);
   }
  else if (childpid==0)
    {
      //child process                                                                                                                                                                                    
      close(PARENT_WRITE);
      close(PARENT_READ);
      dup2(CHILD_READ,0); //read data from pipe instead of stdin                                                                                                                                         
      dup2(CHILD_WRITE , 1);//write data to pipe instead of stdout                                                                                                                                       
      system("python import_modify_graph.py");
      close(CHILD_READ);
      close(CHILD_WRITE);
    }
  else
    {
     close(CHILD_READ);
     close(CHILD_WRITE);
     pipeInput="SOME INPUT";
     c=pipeInput.c_str();
     write(PARENT_WRITE,c,strlen(c));
     close(PARENT_WRITE);
     **read(PARENT_READ,buffer,1000000);**

#定义父项_读取读取管道[0]
#定义子线程写入读取管道[1]
#定义子对象\u读写对象[0]
#定义父对象_WRITE writepe[1]
int writepe[2]={-1，-1}；//父->子
int readpipe[2]={-1，-1}//子->父
pid_t childpid；
字符串管道输入；
常量字符*c；
**字符缓冲区[1000000]//目前为1 MB..**
如果（（childpid=fork（））假设您在Linux下，则可以使用以下方法执行此操作：

fcntl(pipe_fd, F_SETPIPE_SZ, size);

为什么您实际上需要动态增加缓冲区大小？您可以始终在循环中使用
read（）
，以获取更多可用数据。如果确实需要动态增加缓冲区，请使用
std:：vector
并使用
resize（）
function.@πάντα很遗憾，我不能在循环中使用read函数（很难解释为什么，但基本上python文件的编写方式要求read函数只执行一次），我将尝试一下向量char，看看它是如何运行的。谢谢！使用该函数将以前大小的向量传递给
read（）
“很遗憾，我不能在循环中使用read函数（解释原因有点困难，但基本上python文件的编写方式要求read函数只执行一次）”管道缓冲实际上并不依赖于管道的编写端。更大的问题可能是，您的逻辑被构造为将python脚本的输出作为一个整体来查看，而不是在输入片段进入时解析它们。