Running a C++ compiled program in the background and sending input whenever needed

Question

I have a compiled program written in C++ for a UNIX environment which has this kind of structure:

int main(){
...
LoadEngine()
...
while(1){
    std::cin >> buffer;
    ...
    ExecuteFunction(buffer);
}
}

Loading the engine takes quite a while, so I'm trying to start the program in the background first, then send the input whenever I need to.

Running the program with the standard ampersand appended at the end seemingly does not make the program run in the background, but rather halts at std::cin until an input is received from the console, and stops after an input is accepted from the console.

How do I execute the program such that the program runs continuously in the background and receive input and execute the function whenever it is needed?

EDIT: The final product is a small device (RaspberryPi) which recognizes speech, and does something based on the words recognized. The program that I have is the part where the device does something based on the word input, and the word input corresponds to the variable buffer from the code snippet above.

So the std::cin part is a dummy line code that I'm using for testing out that my part of the code starts up in the background process (to load the engine) and does whatever it is designed to do.

EDIT 2 : To clarify what I’m trying to achieve, the program takes an input from a speech recognizer and does things (e.g. synthesize speech from input, send out signals to LEDs, etc.). The text input can be taken directly from the console (which my code is currently doing), or some other method that I’m not knowledgeable in. The only thing that the input adheres to is that it must be a text, and is sent from another program that recognizes speech (which is handled by some other developer). So the exact method isn’t specified. All I have to worry about is my side of the program, which executes a function from a text input (i.e. buffer from the code snippet). So the general structure would look something like this:

Int main(){
LoadEngine()
while(1){
    buffer = ReceiveInput();
    ExecuteFunction(buffer);
 }}

Where the ReceiveInput() part is currently implemented as std::cin. It really can be any method, as long as the engine is loaded once in the beginning, and the program is able to perform ExecuteFunction from an input until the device is turned off.

Answer 1

Unlikely that is possible. In such cases typically you need to listen network port, accept() connection and read from it data, and do whatevet you need. Then you need some client app also to send data. This is how background apps typically work.

Answer 2

This is awkward and inconvenient, but possibly less so than the other answers:

Every time your program asks for input:

1. Get to a shell prompt — and I mean the shell that launched your program.  (I.e., the fact that you're not just running your "engine" program in the foreground suggests that you're using the terminal for something else, like maybe editing files.  Every time your program asks for input, you'll need to save and quit out of the editor, and get back to your primary shell.  Or you may be able to suspend the editor; but that makes the next step more complicated.)
2. Type fg (followed by Enter, of course) to bring your background job into the foreground.  If you have multiple background jobs (as suggested above), do what you need to do to bring your "engine" program into the foreground.
3. Interact with the program.
4. When it's ready to resume running (computing, etc.) for a while, press Ctrl+Z, and then bg (followed by Enter).

Repeat the above as long as the program runs.

Answer 3

You would need to send your application some wake-up call, so it knows when to listen to the input, and where to expect it(since running it in background separates it from the terminal process). The better solution would be(imho) creating separate program that would serve as an interface to the engine - as engine looks like your problem. Provide set of functions to communicate with it, and write simple script that when run, will send input to the engine. Engine will run in background, and other programs will just connect to it. That's the best thing I can come up with at the moment.