C++ pause and resume while(true) loop

[guest1234]

How to design a class, that executes an infinite loop, but may be paused, resumed and stopped by user input? I'll give you an example

class Simulation {
public:
	void start(){
		m.init();
		while(!m.isFinished())
			m.update(); // computationally expensive calculation
	}
	void pause();
	void resume();
	void stop();
private:
	Model m;
};

int main() {
	Simulation s;
	s.start();
	// wait for user input
}

Now obviously s.start() takes up the whole program and there's now way of stopping it properly. It just doesn't have the chance to get user input.
What is the right way to do it? I assume that threads are needed but I have yet no idea how to use them here. Maybe creating a listener class and putting this and model to separate threads? Any help appreciated.

 

[Borek]

Just start calculations in another thread with beginthread().

It will require some tricks, but AFAICT that's the only reasonable approach.

 

[voko]

The answer to this problem depends on your environment. If threads are available, then you could use one thread to run the infinite loop and the other to process IO.

If threads are not available, you may have "signals". Or you may have "messages" which you have to read periodically.

Unless you specify more details, there is no definite answer.

 

[rcgldr]

See if your compiler / operating system supports a function like kbhit() which returns a status to indicate if there's a pending key stroke or not.

 

[LudusRex]

I would suggest using a multi-threaded approach to address this problem. This means creating separate threads for the user input and the simulation loop, allowing them to run concurrently. This way, the user can input commands while the simulation is still running.

One way to implement this is by creating a listener thread that constantly listens for user input. This thread can then communicate with the simulation thread to pause, resume, or stop the loop. The simulation thread can also periodically check for any input from the listener thread and act accordingly.

In terms of design, you could create a class for the listener thread and another class for the simulation thread. These classes can communicate with each other through a shared data structure or by using synchronization techniques such as mutexes or semaphores.

It is important to carefully consider the synchronization and communication between threads to avoid any race conditions or deadlocks. You may also need to handle any potential errors or exceptions that may arise from the multi-threaded approach.

In summary, using multi-threading and careful design can allow for a user to pause, resume, and stop an infinite loop in a C++ program. However, it is important to thoroughly test and debug the implementation to ensure its reliability and stability.