К>>template<class InputIter, class FillValue>
К>>void fill(InputIter i, InputIter e, const FillValue& v)
К>>{
К>>    while(i != e) { *i = v; ++i; }
К>>}
К>>

/* main.cpp */ 

#include <iostream>

using namespace std;

template<class InputIter,class FillValue>
void fill(InputIter i,InputIter e,const FillValue& v)
 {
  while(i != e) { *i = v; ++i; }
 }

/* main() */ 

int main()
 {
  char buf[10];
  
  ::fill(buf,buf+10,char(1));
  
  cout << buf ;
  
  std::fill(buf,buf+10,char(1));
  
  cout << buf ;
  
  memset(buf,1,10);
 
  cout << buf ;
  
  return 0;
 }

; 17   :   char buf[10];
; 18   :   
; 19   :   ::fill(buf,buf+10,char(1));
; 20   :   
; 21   :   cout << buf ;

    mov    edx, DWORD PTR __imp_?cout@std@@3V?$basic_ostream@DU?$char_traits@D@std@@@1@A
    push    esi
    mov    esi, DWORD PTR __imp_??$?6U?$char_traits@D@std@@@std@@YAAAV?$basic_ostream@DU?$char_traits@D@std@@@0@AAV10@PBD@Z
    mov    eax, 16843009                ; 01010101H
    lea    ecx, DWORD PTR _buf$[esp+16]
    mov    DWORD PTR _buf$[esp+16], eax
    push    ecx
    mov    DWORD PTR _buf$[esp+24], eax
    push    edx
    mov    WORD PTR _buf$[esp+32], ax
    call    esi

; 22   :   
; 23   :   std::fill(buf,buf+10,char(1));
; 24   :   
; 25   :   cout << buf ;

    mov    edx, DWORD PTR __imp_?cout@std@@3V?$basic_ostream@DU?$char_traits@D@std@@@1@A
    mov    eax, 16843009                ; 01010101H
    lea    ecx, DWORD PTR _buf$[esp+24]
    mov    DWORD PTR _buf$[esp+24], eax
    push    ecx
    mov    DWORD PTR _buf$[esp+32], eax
    push    edx
    mov    WORD PTR _buf$[esp+40], ax
    call    esi

; 26   :   
; 27   :   memset(buf,1,10);
; 28   :  
; 29   :   cout << buf ;

    mov    edx, DWORD PTR __imp_?cout@std@@3V?$basic_ostream@DU?$char_traits@D@std@@@1@A
    mov    eax, 16843009                ; 01010101H
    lea    ecx, DWORD PTR _buf$[esp+32]
    mov    DWORD PTR _buf$[esp+32], eax
    push    ecx
    mov    DWORD PTR _buf$[esp+40], eax
    push    edx
    mov    WORD PTR _buf$[esp+48], ax
    call    esi

template<class InputIter,class FillValue>
void fill(InputIter i,InputIter e,const FillValue& v)
 {
  while(i != e) { *i = v; ++i; }
 }
 
template<class InputIter,class FillValue>
void fill1(InputIter i,InputIter e,FillValue v)
 {
  while(i != e) { *i = v; ++i; }
 }
 
/* test...() */  

void test1(char *pt,size_t pt_size)
 {
  ::fill(pt,pt+pt_size,char(1));
 }
 
void test2(char *pt,size_t pt_size)
 {
  std::fill(pt,pt+pt_size,char(1));
 }
 
void test3(char *pt,size_t pt_size)
 {
  memset(pt,1,pt_size);
 }
 
void test4(char *pt,size_t pt_size)
 {
  ::fill1(pt,pt+pt_size,char(1));
 }

_TEXT    SEGMENT
_pt$ = 8                        ; size = 4
_pt_size$ = 12                        ; size = 4
?test1@@YAXPADI@Z PROC NEAR                ; test1, COMDAT

; 23   :   ::fill(pt,pt+pt_size,char(1));

    mov    eax, DWORD PTR _pt_size$[esp-4]
    push    edi
    mov    edi, DWORD PTR _pt$[esp]
    lea    ecx, DWORD PTR [edi+eax]
    cmp    edi, ecx
    je    SHORT $L13795
    sub    ecx, edi
    mov    edx, ecx
    shr    ecx, 2
    mov    eax, 16843009                ; 01010101H
    rep stosd
    mov    ecx, edx
    and    ecx, 3
    rep stosb
$L13795:
    pop    edi

; 24   :  }

    ret    0
?test1@@YAXPADI@Z ENDP                    ; test1
_TEXT    ENDS

_TEXT    SEGMENT
_pt$ = 8                        ; size = 4
_pt_size$ = 12                        ; size = 4
?test2@@YAXPADI@Z PROC NEAR                ; test2, COMDAT

; 28   :   std::fill(pt,pt+pt_size,char(1));

    mov    eax, DWORD PTR _pt_size$[esp-4]
    push    edi
    mov    edi, DWORD PTR _pt$[esp]
    lea    ecx, DWORD PTR [edi+eax]
    cmp    edi, ecx
    je    SHORT $L13808
    sub    ecx, edi
    mov    edx, ecx
    shr    ecx, 2
    mov    eax, 16843009                ; 01010101H
    rep stosd
    mov    ecx, edx
    and    ecx, 3
    rep stosb
$L13808:
    pop    edi

; 29   :  }

    ret    0
?test2@@YAXPADI@Z ENDP                    ; test2
_TEXT    ENDS

_TEXT    SEGMENT
_pt$ = 8                        ; size = 4
_pt_size$ = 12                        ; size = 4
?test3@@YAXPADI@Z PROC NEAR                ; test3, COMDAT

; 33   :   memset(pt,1,pt_size);

    mov    ecx, DWORD PTR _pt_size$[esp-4]
    mov    edx, ecx
    push    edi
    mov    edi, DWORD PTR _pt$[esp]
    shr    ecx, 2
    mov    eax, 16843009                ; 01010101H
    rep stosd
    mov    ecx, edx
    and    ecx, 3
    rep stosb
    pop    edi

; 34   :  }

    ret    0
?test3@@YAXPADI@Z ENDP                    ; test3
_TEXT    ENDS

_TEXT    SEGMENT
_pt$ = 8                        ; size = 4
_pt_size$ = 12                        ; size = 4
?test4@@YAXPADI@Z PROC NEAR                ; test4, COMDAT

; 38   :   ::fill1(pt,pt+pt_size,char(1));

    mov    eax, DWORD PTR _pt_size$[esp-4]
    push    edi
    mov    edi, DWORD PTR _pt$[esp]
    lea    ecx, DWORD PTR [edi+eax]
    cmp    edi, ecx
    je    SHORT $L13821
    sub    ecx, edi
    mov    edx, ecx
    shr    ecx, 2
    mov    eax, 16843009                ; 01010101H
    rep stosd
    mov    ecx, edx
    and    ecx, 3
    rep stosb
$L13821:
    pop    edi

; 39   :  }

    ret    0
?test4@@YAXPADI@Z ENDP                    ; test4
_TEXT    ENDS

_TEXT    SEGMENT
_i$ = 8                            ; size = 4
_e$ = 12                        ; size = 4
_v$ = 16                        ; size = 4
??$fill@PADD@@YAXPAD0ABD@Z PROC NEAR            ; fill<char *,char>, COMDAT

; 10   :   while(i != e) { *i = v; ++i; }

    mov    eax, DWORD PTR _i$[esp-4]
    mov    ecx, DWORD PTR _e$[esp-4]
    cmp    eax, ecx
    je    SHORT $L12548
    push    esi
    mov    esi, DWORD PTR _v$[esp]
$L12547:
    mov    dl, BYTE PTR [esi]
    mov    BYTE PTR [eax], dl
    inc    eax
    cmp    eax, ecx
    jne    SHORT $L12547
    pop    esi
$L12548:

; 11   :  }

    ret    0
??$fill@PADD@@YAXPAD0ABD@Z ENDP                ; fill<char *,char>
_TEXT    ENDS

_TEXT    SEGMENT
_i$ = 8                            ; size = 4
_e$ = 12                        ; size = 4
_v$ = 16                        ; size = 1
??$fill1@PADD@@YAXPAD0D@Z PROC NEAR            ; fill1<char *,char>, COMDAT

; 16   :   while(i != e) { *i = v; ++i; }

    mov    ecx, DWORD PTR _e$[esp-4]
    push    edi
    mov    edi, DWORD PTR _i$[esp]
    cmp    edi, ecx
    je    SHORT $L12555
    mov    al, BYTE PTR _v$[esp]
    push    ebx
    mov    bl, al
    mov    bh, bl
    sub    ecx, edi
    mov    edx, ecx
    shr    ecx, 2
    mov    eax, ebx
    shl    eax, 16                    ; 00000010H
    mov    ax, bx
    pop    ebx
    rep stosd
    mov    ecx, edx
    and    ecx, 3
    rep stosb
$L12555:
    pop    edi

; 17   :  }

    ret    0
??$fill1@PADD@@YAXPAD0D@Z ENDP                ; fill1<char *,char>
_TEXT    ENDS

/* main.cpp */ 

#include <iostream>

using namespace std;

struct Complex
 {
  double re;
  double im;
  
  Complex(double re_=0.,double im_=0.) : re(re_),im(im_) {}
  
  const Complex & operator *= (const Complex &);
 };

const Complex & Complex::operator *= (const Complex &x)
 {
  double re_=re;
 
  re = re*x.re - im*x.im ;
  im = re_*x.im + im*x.re ;
  
  return *this;
 }
 
ostream & operator << (ostream &out,const Complex &x) 
 {
  out << "(" << x.re << "," << x.im << ")" ;
 
  return out;
 }
 
/* main() */ 

int main()
 {
  Complex a(2),b(2);
  
  cout << "a*=b " << (a*=b) << "\n" ;
  
  a=Complex(1,1);
  b=Complex(1,1);
  
  cout << "a*=b " << (a*=b) << "\n" ;
  
  a=Complex(1,1);
  
  cout << "a*=a " << (a*=a) << "\n" ;
  
  return 0;
 }

a*=b (4,0)
a*=b (0,2)
a*=a (0,1)
Press any key to continue

memset( mem, 0, size );

A a = {0};

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

#include <iostream>

template <unsigned N> 
struct memset_t : memset_t<(N - 1)> {
  char buf;
  memset_t() : buf(0) {}
};

template <> 
struct memset_t<1> {
  char buf;
  memset_t() : buf(0) {}
};

template <unsigned N> 
inline void fill_mem(void* t) {
  *static_cast<memset_t<N>* >(t) = memset_t<N>();
}

int main() {
  double vvv = 8.9;
  fill_mem<sizeof(vvv)>(&vvv);
  std::cout<<vvv<<std::endl;
}

*((S4*)&dst[0]) = *((S4*)&src[0]);
*((S4*)&dst[4]) = *((S4*)&src[4]);
*((S2*)&dst[8]) = *((S2*)&src[8]);

template<class InputIter, class FillValue>
void fill(InputIter i, InputIter e, const FillValue& v)
{
    while(i != e) { *i = v; ++i; }
}

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

MS>A a = {0};
MS>

template <int N>
struct Filler{
  char buf[N];
};

struct A{
  int x,y,z,u,v;
};

int main(int argc,char* argv[])
{
  A a={1,2,3,4,5};
  typedef Filler<sizeof(A)> AFiller;
  AFiller f={0,};
  *((AFiller*)&a)=f;
  printf("%d,%d,%d,%d,%d\n",a.x,a.y,a.z,a.u,a.v);
  return 0;
}

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;
 }