C / C++ / MFC

A::A()
A::A()
B::B()
A::~A()
A::~A()

A a = A();
A b = B();

"Opinions are neither right nor wrong. I cannot change your opinion. I can, however, change what influences your opinion." - David Crow

When a processor writes to a memory location, the value is cached to improve performance. Similarly, the processor attempts to satisfy read requests from the cache to improve performance. Furthermore, processors begin to fetch values from memory before they are requested by the application. This can happen as part of speculative execution or due to cache line issues.<br />
<br />
As a result, multiple processors can have different views of the system memory state because their caches are out of synch. For example, the following code is not safe on a multiprocessor system:<br />

int iValue;
BOOL fValueHasBeenComputed = FALSE;
extern int ComputeValue();

void CacheComputedValue()
{
  if (!fValueHasBeenComputed) 
  {
    iValue = ComputeValue();
    fValueHasBeenComputed = TRUE;
  }
}

BOOL FetchComputedValue(int *piResult)
{
  if (fValueHasBeenComputed) 
  {
    *piResult = iValue;
    return TRUE;
  } 
  else 
    return FALSE;
}

There is a race condition in this code on multiprocessor systems because the processor that executes CacheComputedValue the first time may write fValueHasBeenComputed to main memory before writing iValue to main memory. Consequently, a second processor executing FetchComputedValue at the same time reads fValueHasBeenComputed as TRUE, because the new value of iValue is still in the first processor's cache.<br />
<br />
Processors can be instructed to force their memory caches to agree with main memory with special instructions. Such instructions ensure that previous read and write requests have completed and are made visible to other processors, and to ensure that that no subsequent read or write requests have started. Examples are:<br />
<br />
Functions which enter or leave critical sections. <br />
Functions which signal synchronization objects. <br />
Wait functions. <br />
Interlocked functions <br />
Consequently, the multiprocessor race condition above can be repaired as follows:

void CacheComputedValue()
{
  if (!fValueHasBeenComputed) {
    iValue = ComputeValue();
    InterlockedExchange((LONG*)&fValueHasBeenComputed, TRUE);
  }
}