How to make a program do something if the user doesn't input anything

I have a bigger project in mind, but I need the answer for this little thing to add to the project.

This is my example code:

#include <iostream>
#include <conio.h>
using namespace std;

int main()
{
    int m=3;
    while (true){
        if (m==1){
            cout<<"m is 1"<<endl;
            system("cls");
        }
        if (m==2){
            cout<<"m is 2"<<endl;
            system("cls");
        }
        if (m==3){
            cout<<"m is 3"<<endl;
            system("cls");
        }
        m=getch();
    }
    return 0;
}

The idea of this code is that and infinite loop exists which prints the current value of m indefinitely. Only when the user inputs a value does the message printed change. But the program doesn't wait for an input, basically it take no input as an instruction to keep doing what it's doing, and if an input is in fact received, the message changes.

In reality this doesn't happen because getch() makes the program stop until an input is received. getch() is somewhat what I want because, unlike cin, it doesn't wait for the user to press enter, but it does wait for something.

So my question is: How do I make a program do the same thing over and over again without stopping, and when an input is received (without having to stop and ask for the input) the output changes?

So my question is: How do I make a program do the same thing over and over again without stopping, and when an input is received (without having to stop and ask for the input) the output changes?

I found getch() and thought it was useful because is doesn't wait for the user to press enter, but it needs an input to continue with the program.

I'm on QT if it matters.

first off, i want to point out some issues in your code:

• You immediately call System"cls"; after you output to console using cout, which clears everything you have printed to console
• instead of chaining if statements, you can change it all to a
cout << "m is " << m << endl;

Now back to your question. i have to explain a lot since what you want to accomplish with getch() is done best in a multi-threaded approach, because getch() locks the current thread for input and you cannot progress the execution on the current thread to continually show input while also waiting for the input. there are other options but if you want to stick with getch() this is one of the ways.

let's take this in steps. first you want two separate threads of execution, one for printing the current input value which is int m in your code, and one for taking the input. To accomplish this, we need a std::thread object, to represent the second thread of execution, so we include the std::thread header to our project:

#include <thread>

now we need a function which takes the input so we can pass it to our second thread and continually run it. this can be best accomplished using anonymous functions or so called lambdas

    auto func = [&m]() 
    {
        while (m != 'q')
        {
            m = _getch();
        }
    };

notice how we capture int m by reference ([&m]) so we can modify it on our other thread. also pay attention to the while's condition statement so we can escape the loop by pressing the q button.

i have further added std::chrono::sleep_for() so the output speed decreases and allows you to see the output values better. after we are finished with our loops, we join the std::thread by calling its join() method. for the final touch, i have modified the int to be atomic to ensure minimal thread-safety. when you put it all together you will have this:

#include <atomic>
#include <chrono>
#include <conio.h>
#include <iostream>
#include <thread>

int main()
{
    std::atomic<int> m = 3;

    auto func = [&m]() {
        while (m.load() != 'q')
        {
            m.store(_getch());
        }
    };

    std::thread thread(func);

    while (m.load() != 'q') {
        std::cout << "m is " << m.load() << std::endl;
        std::this_thread::sleep_for(std::chrono::milliseconds(100));
    }

    thread.join();

    return 0;
}

i strongly suggest reading up on multi-threading and concurrency if you want to delve any deeper. also another tip would be not to use using namespace X; at global scope since in larger projects it may cause name resolving issues, instead get accustomed to typing namespaces whenever possible, for example use std::cout instead of cout.