CODEWITHSUNDEEP
c++interrupt
dalawh
dalawh

Reputation: 924

C++ Interrupts?

I was wondering if C++ had any way of doing interrupts. I want one program to store information in a text file, while the other one prints a statement depending on what is in the text file. Since I want it to be as accurate as possible, I need the print program to be interrupted when the update program updates the file.

Upvotes: 0

Views: 12124

Answers (2)

001
001

Reputation: 13533

If you are using Windows you can use FindFirstChangeNotification.

Here's some old code I have. This is run in it's own thread:

DWORD CDiskWatcher::Run(void *vpParameter)
{
    CFileNotifyInterface *pIface = (CFileNotifyInterface *)vpParameter;

    HANDLE handles[2];
    handles[0] = m_hQuitEvent;
    handles[1] = ::FindFirstChangeNotification(m_szPath, FALSE, FILE_NOTIFY_CHANGE_LAST_WRITE|FILE_NOTIFY_CHANGE_FILE_NAME);
    DWORD dwObject;
    if (INVALID_HANDLE_VALUE != handles[1]) {
        do {
            // Wait for the notification
            dwObject = ::WaitForMultipleObjects(2, handles, FALSE, INFINITE);
            if (WAIT_OBJECT_0 + 1 == dwObject) {
                // Continue waiting...
                ::FindNextChangeNotification(handles[1]);
                pIface->FireFileSystemChange(m_szPath);
            }
        } while (WAIT_OBJECT_0 != dwObject);
        // Close handle
        ::FindCloseChangeNotification(handles[1]);
    }
    return 0;
}

Note m_hQuitEvent is created with CreateEvent() and CFileNotifyInterface is for callbacks:

class CFileNotifyInterface
{
public:
    virtual void FireFileSystemChange(const char *szPath) = 0;
};

Upvotes: 1

paxdiablo
paxdiablo

Reputation: 882566

C++ itself doesn't give this capability, it knows nothing of other programs that may or may not be running.

What you need to look into is IPC (inter-process communications), something your operating system will probably provide.

Things like signals, shared memory, semaphores, message queues and so on.

Since you seem to be using the file itself as the method of delivering content to the other process, signals are probably the way to go. You would simply raise a signal from process A to process B and a signal handler would run in the latter.

Of course this all depends on which operating system you're targeting.

Upvotes: 1

Related Questions