Que hacen los dos puntos aqui

[r0d]

Iniciado por Eternal Idol

r0d: ¿Podes demostrar esa diferencia con alguna documentacion o codigo generado por un compilador?

Lo que pasa es que los compiladores modernos optimizan esto (reemplazan el operador de asignación por el constructor). Pero cuando la variable miembra es un objeto un poco complicado, no puede. Asi que, si fijaos el codigo siguiente por ejemplo:

Código:

#include <string>
#include <iostream>
 
struct Human {
    Human():
    name("John Doe"),
    id(492)
    {}
 
    Human(const std::string& name_, int id_):
    name(name_),
    id(id_)
    {}
 
    std::string name;
    int id;
};
 
struct B {
    B(const Human& a):a_(a) {}
    Human a_;
};
 
struct C {
    C(const Human& a) {
        a_ = a;
    }
 
    Human a_;
};
 
int main()
{
    Human a("Name", 5); 
    B b(a);
    C c(a);

    std::cin.get();
}

El asm del constructor de B y de C seran diferentes. Por ejemplo, compilado con visual c++ 2008 express ed, asi sale el de B:

struct B
{
B(const Human& a):a_(a)
{
00411630 push ebp
00411631 mov ebp,esp
00411633 sub esp,0CCh
00411639 push ebx
0041163A push esi
0041163B push edi
0041163C push ecx
0041163D lea edi,[ebp-0CCh]
00411643 mov ecx,33h
00411648 mov eax,0CCCCCCCCh
0041164D rep stos dword ptr es:[edi]
0041164F pop ecx
00411650 mov dword ptr [ebp-8],ecx
00411653 mov eax,dword ptr [a]
00411656 push eax
00411657 mov ecx,dword ptr [this]
0041165A call Human::Human (4110D7h)
}
0041165F mov eax,dword ptr [this]
00411662 pop edi
00411663 pop esi
00411664 pop ebx
00411665 add esp,0CCh
0041166B cmp ebp,esp
0041166D call @ILT+345(__RTC_CheckEsp) (41115Eh)
00411672 mov esp,ebp
00411674 pop ebp
00411675 ret 4

y asi el asm de C:

struct C
{
C(const Human& a)
00411770 push ebp
00411771 mov ebp,esp
00411773 push 0FFFFFFFFh
00411775 push offset __ehhandler$??0C@@QAE@ABUHuman@@@Z (414A98h)
0041177A mov eax,dword ptr fs:[00000000h]
00411780 push eax
00411781 sub esp,0CCh
00411787 push ebx
00411788 push esi
00411789 push edi
0041178A push ecx
0041178B lea edi,[ebp-0D8h]
00411791 mov ecx,33h
00411796 mov eax,0CCCCCCCCh
0041179B rep stos dword ptr es:[edi]
0041179D pop ecx
0041179E mov eax,dword ptr [___security_cookie (418004h)]
004117A3 xor eax,ebp
004117A5 push eax
004117A6 lea eax,[ebp-0Ch]
004117A9 mov dword ptr fs:[00000000h],eax
004117AF mov dword ptr [ebp-14h],ecx
004117B2 mov ecx,dword ptr [ebp-14h]
004117B5 call Human::Human (411181h)
004117BA mov dword ptr [ebp-4],0
{
a_ = a;
004117C1 mov eax,dword ptr [ebp+8]
004117C4 push eax
004117C5 mov ecx,dword ptr [ebp-14h]
004117C8 call Human::operator= (4111FEh)
}
004117CD mov dword ptr [ebp-4],0FFFFFFFFh
004117D4 mov eax,dword ptr [ebp-14h]
004117D7 mov ecx,dword ptr [ebp-0Ch]
004117DA mov dword ptr fs:[0],ecx
004117E1 pop ecx
004117E2 pop edi
004117E3 pop esi
004117E4 pop ebx
004117E5 add esp,0D8h
004117EB cmp ebp,esp
004117ED call @ILT+345(__RTC_CheckEsp) (41115Eh)
004117F2 mov esp,ebp
004117F4 pop ebp
004117F5 ret 4

No soy experto en asm, pero creo que lo que pasa aquí es que en el constructor de B, el constructor de Human es "inlined".

Iniciado por Eternal Idol

Usar esa sintaxis no te garantiza inicializar todos los miembros, podes olvidarte de algunos perfectamente.

Lo que queria decir, es que si un programador se acostumbra a hacerlo sistemáticamente, y para todas sus variables miembres, estara seguro que su clase esta inicializada correctamente y respeta el RAII.