Simple taxi emulator
Use standard #include guards, not the non-standard #pragma once.
Use standard data types, not DWORD.
Change


this:

static const int NO_ERR = 0;
static const int CAR_IS_BUSY = 1;
static const int DRIVER_IS_BUSY = 2;
static const int NO_DRIVER_FOUND = 3;
static const int CAR_IS_BROKEN = 4; 


into an enum:

enum CarStatus { NO_ERROR, CAR_IS_BUSY, DRIVER_IS_BUSY, NO_DRIVER_FOUND, CAR_IS_BROKEN };



DoMainProcessing is a horrible name and sounds like a function that does way too much. (Update: Okay, that's part of the exercise. Oh, well.)
Consider typedef std::shared_ptr&lt;Car&gt; CarPtr or something, to make the code less cluttered.
Avoid bool in interfaces, as it leads to poor readability and is error prone.


Instead of:

int SetDriverStatus(DWORD driverID, bool onVacation, bool isSick);


Use an enum indicator (or a string) instead:

enum DriverStatus { /* ... */ };
void SetDriverStatus(DriverID driver, DriverStatus newStatus)
{
    // ...
}


The function should be void. (If you are currently returning the old state: Stop doing that, and have a separate function for that. If you are returning a status number to indicate success or not: Use exceptions instead.)


You should probably use the C++ threading library instead of your CreateMutex. (Update: Again, your exercise hinders you from doing the right thing.)
Your use of for_each should be substituted with a range-based for loop.
The exercise states:



  There must be some function, we call it DoMainProcessing, that periodically
  gets called by an external source using the emulator (for example, every second or two).
  It should detect when the driver made the carriage of the customer (depending
  distance and average speed) and is ready to perform the next one. Then, it should
  repair the broken car (subject of availability of sufficient
  number of funds).


The way I understand this, you should update the state of each of your cars and drivers in this function. You should probably record the time between each call, and add the distance traveled to a counter.

Very roughly something like this:

void TaxiPark::DoMainProcessing()
{
    // Use a real library for time, I'm just illustrating.
    Time now = getTime();
    TimeDiff time_difference = now - previous_processing_time;
    previous_processing_time = now;

    for (auto&amp; driver : Drivers) {
        driver.update(time_difference);
    }

    // Updates for cars ...
}


Then, in Driver::update(), you should increase distance traveled based on speed and time difference. If the distance is greater than or equal to the distance of the current ride, the ride is done. Do other state updates as necessary.