Communication with a script from a C++ program

I have a c++ program (very complicated, and lengthy both in code and execution time). Once in a while this program stops and calls a user-specified shell script.

Before calling the script, my program creates a .out file with current data. I call the script via system() command. The script then reads the .out file, and creates its own script.out file and exits.

Then the system() function call ends, and my program reads and parses the script.out file.

Question: is there a better way to execute communication between my c++ program and a random shell script?

My intent is to have full communication between the two. Script could virtually "ask" the program "What data do you have right now?" and the program would reply with some strict convention. Then the script could say "Add this data...", or "delete all your previous data" etc.etc.

The reason I need this is because the sh开发者_如何学JAVAell script tells the program to modify its data. The exact data that was put in the original .out file. So after the modification is done -- the actual data held by the program does not correspond to the data written in the .out file.

Thanks!

P.S. I swear I've searched around, but everyone suggests an intermediate file.

There are certainly ways to do that without intermediate files. The most common approach is to use command line arguments for input, and pipes for standard output; others also use pipes for input. The most straight-forward alternative to system then is to use popen.

On a unix-like system? Perhaps pipe (2) will work for you?

From the man page (Mac OS X 10.5 version):

SYNOPSIS
#include <unistd.h>

int pipe(int fildes[2]);

DESCRIPTION
The pipe() function creates a pipe (an object that allows unidirectional data flow) and allocates a pair of file descriptors. The first descrip- tor connects to the read end of the pipe; the second connects to the write end.

You will, of course, have to follow the creation of the pipes with a fork and exec pair. Probably this has already been answered in detail, and now you know what to search on...

It's been a while since I did this, but:

• In the main process, before forking the sub-process you call pipe twice. Now you have two pipes and control both ends of both of them.
• You fork.
  • The main process will read from one pipe and write from the other. It doesn't matter which is which, but you need to be clear about this.
  • The child process will call one of the exec family of function to replace it's image with that of the shell you want to run but first you will use dup2 to replace it's standard input and output with the ends of the two pipes (again, this is where you need to be clear about which pipe is which).

At his point you have two processes, the main process can send things into one pipe ad they will be received on the standard input of the script, and anything the script writes to it's standard output will be sent up the other pipe to the controlling process. So they take turns, just like interacting with the shell.

You can use pipes or (maybe more convenient) sockets - for example frontends to gdb, or expect do that. It would require changes to your shell scripts, and switching from system() to more low-level fork() and exec().

It's rather complicated so please, be more specific about your environment and what you need to clarify.

You are asking the question on Interprocess Communication (IPC).

There are a lot of ways to do that. You can do a simply search and Internet will return you most answers.

If I am not wrong, Google chrome uses a technique called Named Pipe.

Anyway, I think the most "portable way" is probably a file. But if you know you are working on which operating system, you can definitely use most of the IPC techniques.