MS>memset( mem, 0, size );
MS>

MS>A a = {0};
MS>

template<int N> class dword_fill_t{
public:
    static inline void fill(int* buf, const int& value)
    {
        *buf = value;
        dword_fill_t<N-1>::fill(buf + 1, value);
    }
};

template<> class dword_fill_t<0>{
public:
    static inline void fill(int* buf, const int& value){}
};

template<int N> class byte_fill_t{
public:
    static inline void fill(char* buf, const char& value)
    {
        *buf = value;
        byte_fill_t<N-1>::fill(buf + 1, value);
    }
};

template<> class byte_fill_t<0>{
public:
    static inline void fill(char* buf, const char& value){}
};

template<class X> void zero_fill(X& x)
{
    dword_fill_t<sizeof(x)/sizeof(int)>::fill((int*)&x, 0);
    byte_fill_t<sizeof(x)%sizeof(int)>::fill(((char*)&x) + sizeof(x) - sizeof(x)%sizeof(int), 0);
}

inline void clear_guid(GUID& x)
{
    zero_fill(x);
}

L>template<int N> class dword_fill_t{
L>public:
L>    static inline void fill(int* buf, const int& value)
L>    {
L>        *buf = value;
L>        dword_fill_t<N-1>::fill(buf + 1, value);
L>    }
L>};

L>template<> class dword_fill_t<0>{
L>public:
L>    static inline void fill(int* buf, const int& value){}
L>};

L>template<int N> class byte_fill_t{
L>public:
L>    static inline void fill(char* buf, const char& value)
L>    {
L>        *buf = value;
L>        byte_fill_t<N-1>::fill(buf + 1, value);
L>    }
L>};

L>template<> class byte_fill_t<0>{
L>public:
L>    static inline void fill(char* buf, const char& value){}
L>};

L>template<class X> void zero_fill(X& x)
L>{
L>    dword_fill_t<sizeof(x)/sizeof(int)>::fill((int*)&x, 0);
L>    byte_fill_t<sizeof(x)%sizeof(int)>::fill(((char*)&x) + sizeof(x) - sizeof(x)%sizeof(int), 0);
L>}

L>

L>inline void clear_guid(GUID& x)
L>{
L>    zero_fill(x);
L>}
L>

L>вызов функции clear_guid в релизе транслируется в 4 ассемблерных инструкции mov

char array[4];
zero_fill(array);

// будет эквивалентно
char array[4];
*reinterpret_cast<int*>(&array) = 0; // здесь возможен fault, т.к. array не обязательно будет выровнен на 4

...
    //    композиция преобразований
    matrix& operator*= (const matrix &rht)
    {
        matrix temp = {0};

                matrix &lft = (*this);

        for(size_t i = 0; i<4; i++)
        for(size_t j = 0; j<4; j++)
        for(size_t k = 0; k<4; k++)    
            temp[i][j] +=  lft[i][k] * rht[k][j];
                
                lft = temp;

                return (*this);
    } // operator *=..

const Complex & Complex::operator *= (const Complex &x)
 {
  const Complex& tmp=this==&x?Complex(x):x;
  double re_=re;

  re = re*tmp.re - im*tmp.im ;
  im = re_*tmp.im + im*tmp.re ;

  return *this;
 }

EX>будучи откомпилённым борландом 5.5

const Complex & Complex::operator *= (const Complex &x)
 {
  double re_ = re*x.re - im*x.im ;
  double im_ = re*x.im + im*x.re ;
  
  re=re_;
  im=im_;
  
  return *this;
 }