The ATL CTime implementation uses inline functions and static data.

I used the CTime class because that class caused te trouble in my
application ( ATL CTime  uses inline functions and static data ).
But maybe the following code demonstrates more directly the effect:

#include "stdafx.h"

static int iStatic;

class CBuggy
{
public:
  CBuggy(int iValue);
  inline int GetValue();
private:
  int _iValue;
};

CBuggy::CBuggy(int iValue) : _iValue(iValue) { }

int CBuggy::GetValue()
{
  return (iStatic = _iValue);
}

int _tmain(int argc, _TCHAR* argv[])
{
  CBuggy b1(1);
  CBuggy b2(2);

  printf("b1 = %d, b2 = %d\n", b1.GetValue(), b2.GetValue());
  return 0;
}
---
Output is:
b1 = 1, b2 = 1     (but one would expect that b2 = 2).

When the GetValue() function is not inline all goes well.

The only thing that helps is disabling the inline function. The compiler
generates wrong code (even without optimization it seems ).

Assembly output when the function is inline:
    mov    eax, DWORD PTR _b2$[ebp]
    mov    DWORD PTR _iStatic, eax
    mov    ecx, DWORD PTR _b1$[ebp]    
    mov    DWORD PTR _iStatic, ecx
    mov    edx, DWORD PTR _iStatic  
    push    edx
    mov    eax, DWORD PTR _iStatic
    push    eax
    push    OFFSET FLAT:$SG71576
    call    _printf

After the instruction that moves eax to address _iStatic, the value of eax
should have been pushed on the stack. But the compiler delays this
instruction until after the second inline function. And than it's too late
because the value of iStatic has already changed again.