#include <stdio.h>

class Base
{
public:
    Base() : add_(123)
     {
     }

    int add(int x, int y)
     {
     return x + y + add_;
     }
     
protected:
    int add_;
};

class Test : public Base
{
};

int main(int argc, char *argv[])
{
printf("%d\n", Test().add(1, 2));
return 0;
}

PUBLIC    _main
EXTRN    _printf:NEAR
; Function compile flags: /Ogty
_TEXT    SEGMENT
_argc$ = 8                        ; size = 4
_argv$ = 12                        ; size = 4
_main    PROC NEAR

; 25   : printf("%d\n", Test().add(1, 2));

    push    126                    ; 0000007eH
    push    OFFSET FLAT:$SG633
    call    _printf
    add    esp, 8

; 26   : return 0;

    xor    eax, eax

; 27   : }

    ret    0
_main    ENDP

// виртуальные функции. Realloc обязан быть реализован
void Func( IMalloc* I )
{
  void* p  = I->Alloc( 100 );
  void* p2 = I->Realloc( p, 200 );
  if ( NULL != p2 )
    p = p2;
  ...
}

// таблицы функций. Realloc не обязан быть реализован
// Попробуйте реализовать такой C++ интерфейс, у которого I->Realloc будет NULL
void Func( IMalloc* I )
{
  void* p  = I->Alloc( 100 );
  if ( NULL != I->Realloc )
  {
     void* p2 = I->Realloc( p, 200 );
     if ( NULL != p2 )
       p = p2;
  }
  else
  {
     void* p2 = I->Alloc( 200 );
     if ( NULL != p2 )
     {
       memcpy( p2, p, 100 );
       I->Free( p );
       p = p2;
     }
  }
  ...
}

struct IMalloc
{
    virtual void* alloc(size_t)=0;
    virtual void  free(void*)=0;
    virtual void* realloc(void*, size_t)=0;
};
struct IMapingMalloc : public IMalloc
{
    virtual void mmap(...)=0;
};

C>struct IMalloc
C>{
C>    virtual void* alloc(size_t)=0;
C>    virtual void  free(void*)=0;
C>    virtual void* realloc(void*, size_t)=0;
C>};
C>struct IMapingMalloc : public IMalloc
C>{
C>    virtual void mmap(...)=0;
C>};
C>

struct IFs
{
  virtual int open(int) = 0;
  virtual void  close(int) = 0;
};

struct IMyFs : public IFs
{
  virtual int open(int);
  virtual void  close(int);
};
IMyFs* module_init();

// Для каждого зарегистрированного модуля (сервера)
IFs* fs = module_init();
fs->open(3);

struct IFs
{
  virtual int open(int) = 0;
  virtual void  close(int) = 0;
  virtual int open(char*) = 0;
};

// Для каждого зарегистрированного модуля (сервера)
IFs* fs = module_init();
if ( NULL != fs->open2 )
  fs->open2( "/tmp" );
else
  fs->open(3);

struct IFsWithCharStar : public IFs
{
    virtual int open(char*) = 0;
};

IFsWithCharStar *efs=dynamic_cast<IFsWithCharStar *>(fs);
if (efs)
    efs->open2(...);
else
    fs->open(...);

struct IMalloc
{
  virtual void* Realloc()
  {
    return 0;
  }
};

std::auto_ptr<IMalloc> a (new AllocImpl());
// выполняем действия с одной реализацией
a.reset(new AnotherAllocImpl); // Подменяем одну (или несколько) функций в таблице
// выполняем действия с другой реализацией

R>struct IMalloc
R>{
R>  virtual void* Realloc()
R>  {
R>    return 0;
R>  }
R>};
R>

R>std::auto_ptr<IMalloc> a (new AllocImpl());
R>// выполняем действия с одной реализацией
R>a.reset(new AnotherAllocImpl); // Подменяем одну (или несколько) функций в таблице
R>// выполняем действия с другой реализацией
R>

void bar( IMalloc* I );
void foo( IMalloc* I )
{
  // Подмените здесь метод I->Realloc
  bar( I );
  // Восстановите метод I->Realloc
}

R>>struct IMalloc
R>>{
R>>  virtual void* Realloc()
R>>  {
R>>    return 0;
R>>  }
R>>};
R>>

R>>std::auto_ptr<IMalloc> a (new AllocImpl());
R>>// выполняем действия с одной реализацией
R>>a.reset(new AnotherAllocImpl); // Подменяем одну (или несколько) функций в таблице
R>>// выполняем действия с другой реализацией
R>>

MS>void bar( IMalloc* I );
MS>void foo( IMalloc* I )
MS>{
MS>  // Подмените здесь метод I->Realloc
MS>  bar( I );
MS>  // Восстановите метод I->Realloc
MS>}
MS>

IMalloc* I = new MallocImpl(new Strategy1Impl5(), new Strategy2Impl3());

// Подмените здесь метод I->Realloc
I->setStrategy2(new Strategy2Impl4());
bar( I );
// Восстановите метод I->Realloc
I->setStrategy2(new Strategy2Impl3());

struct IFsExt : public IFs
{
    virtual int open(char*) = 0;
};
>>  struct IFs
>>  {
>>  virtual int open(int) = 0;
>>  virtual void close(int) = 0;
virtual IFsExt *getExt() {return NULL};
>>  };

>>  IFs* fs = module_init();
>>  if ( NULL != fs->open2 )
>>  fs->open2( "/tmp" );
>>  else
>>  fs->open(3);

IFs *fs = module_init();
IFsExt *fsExt = fs->getExt();
if(fsExt)//всего одна проверка, затем смело используем весь интерфейс без лишних проверок.
{
   fsExt->open(/"tmp");
   fsExt->close(5);
}
else
{
   fs->open(3);
   fs->close(5);
}

void func()
{
  std::string s = "this is my string";
}

std::string s = "just a string";

const_string<char> str(boost::cref("just a string"));

char* request = ...;

int generateSome()
{
  char* xxx = request;
  int len = strlen(request); //1
}

send(sock, request, strlen(request), 0); //2

int generateSome2()
{
  char* xxx2 = request;
  int len2 = strlen(request); //3
}

if (strncmp(request, request2, min(strlen(request), strlen(request2))); //3 //4

typedef struct
{
  char* str;
  int len;
} string;

Generic Programming and the STL: Using and Extending the C++ Standard Template Library (Hardcover)
by Matthew H. Austern

. . .

This is not a book about object-oriented programming.

You may think that's odd. You probably found this book in the C++ section of the bookstore, after all, and you've probably heard people use object oriented and C++ synonymously, but that isn't the only way to use the C++ language. C++ supports several fundamentally different paradigms, the newest and least familiar of which is generic programming.

(http://www.amazon.com/gp/product/0201309564/sr=8-6/qid=1155312739/ref=pd_bbs_6/104-6863636-3097568?ie=UTF8)

string Func( string person, string phone, string address )
{
  string ret = person + " : " + phone + " : " + address;
  ...
  return ret;
}

struct A
{
   A():i(0){}
   int i;
};
...
    A a;
...

struct A
{
   int i;
};
void constructA(A *a)
{
   a->i = 0;
}
...
    A a;
    constructA(&a);
...

Основное преимущество библиотек написанных на C (вернее с C интерфейсом) — их использование.
Попробуйте написать на C++ библиотеку аналог WinAPI, чтобы ей могли пользоваться из VB, Дельфи, а также из разных версий компилятора C++ с разными STL.
ЭТО НЕВОЗМОЖНО.

void some_func()
{
  some_struct s;
  bool s_init = false;

  //...

  if (a)
  {
    //...
    init_some_struct(&s);
    s_init = true;
    //...
  }

  //...

  if (b)
  {
    //...
    if (s_init)
       uninit_some_struct(&s);
    return;
  }

  //...

  if (s_init)
     uninit_some_struct(&s);
}

void func()
{
    char *ptr1=NULL,*ptr2=NULL;
    ptr1=malloc(...);
    if (!ptr1) goto err_1;
    ptr2=malloc(...);
    if (!ptr2) goto err_2;

    err2: free(ptr2);
    err1: free(ptr1);
};

R>Ты лучше скажи по поводу s_init

void some_func()
{
  some_struct s;
  bool s_init = false;

  //...

  if (a)
  {
    //...
    init_some_struct(&s);
    s_init = true;
    //...
  }

  //...

  if (b)
  {
    //...
    goto Exit;
//    if (s_init)
//       uninit_some_struct(&s);
//    return;
  }

  //...

Exit:
  if (s_init)
     uninit_some_struct(&s);
}

struct A
{
   string data;
};

vector<A> my_vector;

a1 = { "test" };
a2 = { "some other " };

my_vector.push_back( a1 ); 
my_vector.push_back( a2 );

scoped_array<char> arr1(new char[...]);
scoped_array<char> arr2(new char[...]);

void Func()
{
  int res = -1;
  char* a, *b;

  a = (char*)malloc( 100 );
  if ( NULL == a )
    goto Exit;
  res = 0;

  b = (char*)malloc( 100 );
  if ( NULL == b )
    goto Exit;
  res = 1;

  err = Func2( a, b );

Exit:
  switch( res )
  {
    case 1: free( b );
    case 0: free( a );
  }
}

C>scoped_array<char> arr1(new char[...]);
C>scoped_array<char> arr2(new char[...]);
C>

#include <memory>
using namespace std;

void FuncCpp( auto_ptr<char>& a, auto_ptr<char>& b );

void TestCpp()
{
  auto_ptr<char> a ( new char [100] );
  auto_ptr<char> b ( new char [100] );

  FuncCpp( a, b );
}

#include <errno.h>
unsigned FuncC( char* a, char* b );
int TestC()
{
  int err = -ENOMEM;
  char* a, *b;

  a = (char*)malloc( 100 );
  if ( NULL == a )
    goto end1;

  b = (char*)malloc( 100 );
  if ( NULL == b )
    goto end2;

  err = FuncC( a, b );

  free( b );
end2:
  free( a );
end1:
  return err;
}

.text:00000000 ; int __cdecl TestC(void)
.text:00000000                 push    ebx
.text:00000001                 push    edi
.text:00000002                 push    64h ; 'd'
.text:00000004                 mov     ebx, 0FFFFFFF4h
.text:00000009                 call    _malloc
.text:0000000E                 mov     edi, eax
.text:00000010                 add     esp, 4
.text:00000013                 test    edi, edi
.text:00000015                 jz      short loc_44
.text:00000017                 push    esi
.text:00000018                 push    64h ; 'd'
.text:0000001A                 call    _malloc
.text:0000001F                 mov     esi, eax
.text:00000021                 add     esp, 4
.text:00000024                 test    esi, esi
.text:00000026                 jz      short loc_3A
.text:00000028                 push    esi
.text:00000029                 push    edi
.text:0000002A                 call    ?FuncC@@YAIPAD0@Z ; FuncC(char *,char *)
.text:0000002F                 push    esi
.text:00000030                 mov     ebx, eax
.text:00000032                 call    _free
.text:00000037                 add     esp, 0Ch
.text:0000003A 
.text:0000003A loc_3A:                                 ; CODE XREF: TestC(void)+26j
.text:0000003A                 push    edi
.text:0000003B                 call    _free
.text:00000040                 add     esp, 4
.text:00000043                 pop     esi
.text:00000044 
.text:00000044 loc_44:                                 ; CODE XREF: TestC(void)+15j
.text:00000044                 pop     edi
.text:00000045                 mov     eax, ebx
.text:00000047                 pop     ebx
.text:00000048                 retn
.text:00000048 ?TestC@@YAHXZ   endp
.text:00000048 
.text:00000048 _text           ends

               Зачем здесь сгенерен конструктор?
.text:0000004A ; public: __thiscall std::auto_ptr<char>::auto_ptr<char>(char *)
.text:0000004A arg_0           = dword ptr  4
.text:0000004A 
.text:0000004A                 mov     eax, ecx
.text:0000004C                 mov     ecx, [esp+arg_0]
.text:00000050                 mov     [eax], ecx
.text:00000052                 retn    4
.text:00000052 ??0?$auto_ptr@D@std@@QAE@PAD@Z endp
.text:00000052 
.text:00000052 _text           ends
.text:00000052 
.text:00000056 
.text:00000056 ; public: __thiscall std::auto_ptr<char>::~auto_ptr<char>(void)
.text:00000056                 mov     eax, [ecx]
.text:00000058                 push    eax
.text:00000059                 call    ??3@YAXPAX@Z    ; operator delete(void *)
.text:0000005E                 pop     ecx
.text:0000005F                 retn
.text:0000005F ??1?$auto_ptr@D@std@@QAE@XZ endp
.text:0000005F 
.text:0000005F _text           ends
.text:0000005F 
.text:00000060 ; void __cdecl TestCpp(void)
.text:00000060 
.text:00000060 var_14          = dword ptr -14h
.text:00000060 var_10          = dword ptr -10h
.text:00000060 var_C           = dword ptr -0Ch
.text:00000060 var_4           = dword ptr -4
.text:00000060 
.text:00000060                 push    0FFFFFFFFh
.text:00000062                 push    offset __ehhandler$?TestCpp@@YAXXZ
.text:00000067                 mov     eax, dword ptr fs:__except_list
.text:0000006D                 push    eax
.text:0000006E                 mov     dword ptr fs:__except_list, esp
.text:00000075                 sub     esp, 8
.text:00000078                 push    64h ; 'd'
.text:0000007A                 call    ??_U@YAPAXI@Z
.text:0000007F                 mov     [esp+18h+var_10], eax
.text:00000083                 push    64h ; 'd'
.text:00000085                 mov     [esp+1Ch+var_4], 0            <--- Что это за переменная?
.text:0000008D                 call    ??_U@YAPAXI@Z
.text:00000092                 mov     [esp+1Ch+var_14], eax
.text:00000096                 lea     eax, [esp+1Ch+var_14]
.text:0000009A                 push    eax
.text:0000009B                 lea     ecx, [esp+20h+var_10]
.text:0000009F                 push    ecx
.text:000000A0                 mov     byte ptr [esp+24h+var_4], 1    <--- Что это за переменная?
.text:000000A5                 call    ?FuncCpp@@YAXAAV?$auto_ptr@D@std@@0@Z ; FuncCpp(std::auto_ptr<char> &,std::auto_ptr<char> &)
.text:000000AA                 mov     edx, [esp+24h+var_14]
.text:000000AE                 push    edx
.text:000000AF                 call    ??3@YAXPAX@Z    ; operator delete(void *)
.text:000000B4                 mov     eax, [esp+28h+var_10]
.text:000000B8                 push    eax
.text:000000B9                 call    ??3@YAXPAX@Z    ; operator delete(void *)
.text:000000BE                 mov     ecx, [esp+2Ch+var_C]
.text:000000C2                 mov     dword ptr fs:__except_list, ecx
.text:000000C9                 add     esp, 2Ch
.text:000000CC                 retn
.text:000000CC ?TestCpp@@YAXXZ endp
.text:000000CC 
.text:000000CC _text           ends
.text:000000CC 
.text$x:000000CE 
.text$x:000000CE $L48140         proc near               ; DATA XREF: .xdata$x:000000ECo
.text$x:000000CE                 lea     ecx, [ebp-10h]
.text$x:000000D1                 jmp     ??1?$auto_ptr@D@std@@QAE@XZ ; std::auto_ptr<char>::~auto_ptr<char>(void)
.text$x:000000D1 $L48140         endp
.text$x:000000D1 
.text$x:000000D6 
.text$x:000000D6 $L48141         proc near               ; DATA XREF: .xdata$x:000000F4o
.text$x:000000D6                 lea     ecx, [ebp-14h]
.text$x:000000D9                 jmp     ??1?$auto_ptr@D@std@@QAE@XZ ; std::auto_ptr<char>::~auto_ptr<char>(void)
.text$x:000000D9 $L48141         endp
.text$x:000000D9 
.text$x:000000DE 
.text$x:000000DE __ehhandler$?TestCpp@@YAXXZ proc near   ; DATA XREF: TestCpp(void)+2o
.text$x:000000DE                 mov     eax, offset $T48161
.text$x:000000E3                 jmp     ___CxxFrameHandler
.text$x:000000E3 __ehhandler$?TestCpp@@YAXXZ endp
.text$x:000000E3 
.text$x:000000E3 _text$x         ends
.text$x:000000E3 
.xdata$x:000000E8 ; ===========================================================================
.xdata$x:000000E8 
.xdata$x:000000E8 ; Segment type: Pure data
.xdata$x:000000E8 _xdata$x        segment dword public 'DATA' use32
.xdata$x:000000E8                 assume cs:_xdata$x
.xdata$x:000000E8                 ;org 0E8h
.xdata$x:000000E8 $T48164         dd 0FFFFFFFFh           ; DATA XREF: .xdata$x:00000100o
.xdata$x:000000EC                 dd offset $L48140
.xdata$x:000000F0                 dd 0
.xdata$x:000000F4                 dd offset $L48141
.xdata$x:000000F8 $T48161         dd 19930520h            ; DATA XREF: __ehhandler$?TestCpp@@YAXXZo
.xdata$x:000000FC                 dd 2
.xdata$x:00000100                 dd offset $T48164
.xdata$x:00000104                 dd 0
.xdata$x:00000108                 dd 0
.xdata$x:0000010C                 dd 0
.xdata$x:00000110                 dd 0
.xdata$x:00000110 _xdata$x        ends

PUBLIC    ?TestC@@YAHXZ                    ; TestC
EXTRN    _free:NEAR
EXTRN    _malloc:NEAR
; Function compile flags: /Ogty
;    COMDAT ?TestC@@YAHXZ
_TEXT    SEGMENT
?TestC@@YAHXZ PROC NEAR                    ; TestC, COMDAT

; 30   : {

    push    esi
    push    edi

; 31   :   int err = -ENOMEM;
; 32   :   char* a, *b;
; 33   :
; 34   :   a = (char*)malloc( 100 );

    push    100                    ; 00000064H
    mov    esi, -12                ; fffffff4H
    call    _malloc
    mov    edi, eax
    add    esp, 4

; 35   :   if ( NULL == a )

    test    edi, edi
    je    SHORT $L10293

; 36   :     goto end1;
; 37   :
; 38   :   b = (char*)malloc( 100 );

    push    100                    ; 00000064H
    call    _malloc
    add    esp, 4

; 39   :   if ( NULL == b )

    test    eax, eax
    je    SHORT $end2$8985

; 40   :     goto end2;
; 41   :
; 42   :   err = FuncC( a, b );
; 43   :
; 44   :   free( b );

    push    eax
    xor    esi, esi
    call    _free
    add    esp, 4
$end2$8985:

; 45   : end2:
; 46   :   free( a );

    push    edi
    call    _free
    add    esp, 4
$L10293:
    pop    edi

; 47   : end1:
; 48   :   return err;

    mov    eax, esi
$end1$8981:
    pop    esi

; 49   : }

    ret    0
?TestC@@YAHXZ ENDP                    ; TestC

?TestCpp@@YAXXZ PROC NEAR                ; TestCpp, COMDAT

; 12   : {

    push    -1
    push    __ehhandler$?TestCpp@@YAXXZ
    mov    eax, DWORD PTR fs:__except_list
    push    eax
    mov    DWORD PTR fs:__except_list, esp
    push    ecx
    push    esi

; 13   :     std::auto_ptr<char> a ( new char [100] );

    push    100                    ; 00000064H
    call    ??_U@YAPAXI@Z                ; operator new[]
    mov    esi, eax
    mov    DWORD PTR _a$[esp+24], esi

; 14   :     std::auto_ptr<char> b ( new char [100] );

    push    100                    ; 00000064H
    mov    DWORD PTR __$EHRec$[esp+36], 0
    call    ??_U@YAPAXI@Z                ; operator new[]

; 15   :     FuncCpp( a, b );
; 16   : }

    push    eax
    call    ??3@YAXPAX@Z                ; operator delete
    push    esi
    call    ??3@YAXPAX@Z                ; operator delete
    mov    ecx, DWORD PTR __$EHRec$[esp+36]
    add    esp, 16                    ; 00000010H
    pop    esi
    mov    DWORD PTR fs:__except_list, ecx
    add    esp, 16                    ; 00000010H
    ret    0
_TEXT    ENDS
;    COMDAT text$x
text$x    SEGMENT
$L10399:
    lea    ecx, DWORD PTR _a$[ebp]
    jmp    ??1?$auto_ptr@D@std@@QAE@XZ        ; std::auto_ptr<char>::~auto_ptr<char>
__ehhandler$?TestCpp@@YAXXZ:
    mov    eax, OFFSET FLAT:$T10423
    jmp    ___CxxFrameHandler
text$x    ENDS
?TestCpp@@YAXXZ ENDP                    ; TestCpp

при простом включении опции "enable exception handling"

char *buf = malloc(100);
buf[1]=5;

char *buf = malloc(100);
if(buf == NULL) goto removeAllResourcesAndFindAppropriateCatchBlock;
buf[1]=5;

cyberax@scblinux:~/compare$ gcc --version
gcc (GCC) 4.1.2 20060729 (prerelease) (Debian 4.1.1-10)
Copyright (C) 2006 Free Software Foundation, Inc.
This is free software; see the source for copying conditions.  There is NO
warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
cyberax@scblinux:~/compare$ uname -a
Linux scblinux 2.6.17.7 #3 Mon Aug 7 19:23:59 UTC 2006 x86_64 GNU/Linux
cyberax@scblinux:~/compare$ gcc -O2 -S -fPIC test.c

    .type    TestC, @function
TestC:
.LFB12:
    movq    %rbp, -16(%rsp)
.LCFI0:
    movq    %r12, -8(%rsp)
.LCFI1:
    movl    $100, %edi
    movq    %rbx, -24(%rsp)
.LCFI2:
    subq    $24, %rsp
.LCFI3:
    movl    $-12, %r12d
    call    malloc@PLT
    testq    %rax, %rax
    movq    %rax, %rbp
    je    .L4
    movl    $100, %edi
    call    malloc@PLT
    testq    %rax, %rax
    movq    %rax, %rbx
    je    .L7
    movq    %rbp, %rdi
    movq    %rax, %rsi
    call    FuncC@PLT
    movq    %rbx, %rdi
    movl    %eax, %r12d
    call    free@PLT
.L7:
    movq    %rbp, %rdi
    call    free@PLT
.L4:
    movl    %r12d, %eax
    movq    (%rsp), %rbx
    movq    8(%rsp), %rbp
    movq    16(%rsp), %r12
    addq    $24, %rsp
    ret

.globl _Z7TestCppv
    .type    _Z7TestCppv, @function
_Z7TestCppv:
.LFB447:
    pushq    %rbx
.LCFI0:
    movl    $100, %edi
    subq    $32, %rsp
.LCFI1:
.LEHB0:
    call    _Znam@PLT
.LEHE0:
    movl    $100, %edi
    movq    %rax, 16(%rsp)
.LEHB1:
    call    _Znam@PLT
.LEHE1:
    movq    %rax, (%rsp)
    movq    %rsp, %rsi
    leaq    16(%rsp), %rdi
.LEHB2:
    call    _Z7FuncCppRSt8auto_ptrIcES1_@PLT
.LEHE2:
    movq    (%rsp), %rdi
    call    _ZdlPv@PLT
    movq    16(%rsp), %rdi
    call    _ZdlPv@PLT
    addq    $32, %rsp
    popq    %rbx
    ret

.L7:
    movq    %rax, %rbx
.L4:
    movq    16(%rsp), %rdi
    call    _ZdlPv@PLT
    movq    %rbx, %rdi
.LEHB3:
    call    _Unwind_Resume@PLT
.LEHE3:
.L6:
.L3:
    movq    (%rsp), %rdi
    movq    %rax, %rbx
    call    _ZdlPv@PLT
    jmp    .L4
.LFE447:
    .size    _Z7TestCppv, .-_Z7TestCppv
.globl __gxx_personality_v0
    .section    .gcc_except_table,"a",@progbits
.LLSDA447:
    .byte    0xff
    .byte    0xff
    .byte    0x1
    .uleb128 .LLSDACSE447-.LLSDACSB447
.LLSDACSB447:
    .uleb128 .LEHB0-.LFB447
    .uleb128 .LEHE0-.LEHB0
    .uleb128 0x0
    .uleb128 0x0
    .uleb128 .LEHB1-.LFB447
    .uleb128 .LEHE1-.LEHB1
    .uleb128 .L7-.LFB447
    .uleb128 0x0
    .uleb128 .LEHB2-.LFB447
    .uleb128 .LEHE2-.LEHB2
    .uleb128 .L6-.LFB447
    .uleb128 0x0
    .uleb128 .LEHB3-.LFB447
    .uleb128 .LEHE3-.LEHB3
    .uleb128 0x0
    .uleb128 0x0

#include <memory>
using namespace std;

void FuncCpp( auto_ptr<char>& a, auto_ptr<char>& b, int );

void TestCpp()
{
  auto_ptr<char> a ( new char [100] );
  auto_ptr<char> b ( new char [100] );

  try
  {
    FuncCpp( a, b, 0 );
  }
  catch( ... )
  {
    FuncCpp( a, b, 1 );
  }
}

#include <errno.h>
unsigned FuncC( char* a, char* b, int );
int TestC()
{
  int err = -ENOMEM;
  char* a, *b;

  a = (char*)malloc( 100 );
  if ( NULL == a )
    goto end1;

  b = (char*)malloc( 100 );
  if ( NULL == b )
    goto end2;

  err = FuncC( a, b, 0 );
  if ( 0 != err )
    err = FuncC( a, b, 1 );

  free( b );
end2:
  free( a );
end1:
  return err;
}

         .type   _Z7TestCppv, @function
_Z7TestCppv:
.LFB447:
         movq    %rbx, -24(%rsp)
.LCFI0:
         movq    %rbp, -16(%rsp)
.LCFI1:
         movl    $100, %edi
         movq    %r12, -8(%rsp)
.LCFI2:
         subq    $56, %rsp
.LCFI3:
.LEHB0:
         call    _Znam@PLT
.LEHE0:
         movl    $100, %edi
         movq    %rax, 16(%rsp)
.LEHB1:
         call    _Znam@PLT
.LEHE1:
         leaq    16(%rsp), %rbp
         movq    %rax, (%rsp)
         xorl    %edx, %edx
         movq    %rsp, %rsi
         movq    %rbp, %rdi
.LEHB2:
         call    _Z7FuncCppRSt8auto_ptrIcES1_i@PLT
.LEHE2:
.L2:
         movq    (%rsp), %rdi
         call    _ZdlPv@PLT
         movq    16(%rsp), %rdi
         call    _ZdlPv@PLT
         movq    32(%rsp), %rbx
         movq    40(%rsp), %rbp
         movq    48(%rsp), %r12
         addq    $56, %rsp
         ret

.L13:
         movq    %rax, %r12
.L7:
         movq    16(%rsp), %rdi
         call    _ZdlPv@PLT
         movq    %r12, %rdi
.LEHB3:
         call    _Unwind_Resume@PLT
.LEHE3:
.L11:
.L3:
         movq    %rax, %rdi
         call    __cxa_begin_catch@PLT
         movl    $1, %edx
         movq    %rsp, %rsi
         movq    %rbp, %rdi
.LEHB4:
         call    _Z7FuncCppRSt8auto_ptrIcES1_i@PLT
.LEHE4:
.LEHB5:
         call    __cxa_end_catch@PLT
.LEHE5:
         jmp     .L2
.L10:
.L5:
         movq    %rax, %r12
         .p2align 4,,6
         call    __cxa_end_catch@PLT
.L6:
         movq    (%rsp), %rdi
         call    _ZdlPv@PLT
         jmp     .L7
.L12:
         movq    %rax, %r12
         .p2align 4,,4
         jmp     .L6

         .type   TestC, @function
TestC:
.LFB12:
         movq    %rbp, -16(%rsp)
.LCFI0:
         movq    %r12, -8(%rsp)
.LCFI1:
         movl    $100, %edi
         movq    %rbx, -24(%rsp)
.LCFI2:
         subq    $24, %rsp
.LCFI3:
         movl    $-12, %r12d
         call    malloc@PLT
         testq   %rax, %rax
         movq    %rax, %rbp
         je      .L4
         movl    $100, %edi
         call    malloc@PLT
         testq   %rax, %rax
         movq    %rax, %rbx
         je      .L7
         xorl    %edx, %edx
         movq    %rax, %rsi
         movq    %rbp, %rdi
         call    FuncC@PLT
         xorl    %r12d, %r12d
         testl   %eax, %eax
         jne     .L13
.L10:
         movq    %rbx, %rdi
         call    free@PLT
.L7:
         movq    %rbp, %rdi
         call    free@PLT
.L4:
         movl    %r12d, %eax
         movq    (%rsp), %rbx
         movq    8(%rsp), %rbp
         movq    16(%rsp), %r12
         addq    $24, %rsp
         ret
         .p2align 4,,7