class CFakeArgument {
    typedef double alignAs_t; // можно прагамами, С++11 или ещё как замутить, не суть.
    enum { bufSize = 32 }; // В общем сколько стеку не жаль
    
    struct CBuffer {
        alignAs_t alignPad;
        char bytes[bufSize - sizeof( alignAs_t )];
    } buffer;

    typedef  void deleter_t( void* );
    deleter_t* deleter;
    void* data;
    
    CFakeArgument( const CFakeArgument& ); // = delete
    void operator = ( const CFakeArgument& ); // = delete
    
    //    Полиморфная часть
    template<typename T> 
    struct CData {
        T Data;
        
        void* operator new( size_t size, CBuffer& dstBuffer )
        {
            if( sizeof( CData ) <= bufSize ) {
                assert( size <= bufSize );
                return &dstBuffer;
            } else {
                return ::new char[size];
            }
        }

        void operator delete( void* p, CBuffer& dstBuffer )
        {
            if( sizeof( CData ) <= bufSize ) {
                assert( p == 0 || p == &dstBuffer );
            } else {
                ::delete[] (char*)p;
            }
        }

        void operator delete( void* p )
        {
            if( sizeof( CData ) > bufSize ) {
                ::delete[] (char*)p;
            }
        }

        static void deleter( void* p )
        {
            delete static_cast<CData*>( p );
        }
        
        T& Save( void*& thisStorage, deleter_t*& deleterStorage )
        {
            assert( thisStorage == 0 && deleterStorage == 0 );
            thisStorage = this;
            deleterStorage = deleter;
            return Data;
        }
    };
    
    template<typename T> 
    struct CData<const T> : CData<T> {};


public:
    CFakeArgument() : deleter( 0 ), data( 0 ) {}; // По просьбам трудящихся ;)
    ~CFakeArgument() { if(deleter != 0 ) deleter( data ); }
    
    template<typename T>
    operator T&()
    {
        if( data == 0 ) {
            return ( new( buffer ) CData<T> )-> Save( data, deleter );
        } else {
            assert( deleter == CData<T>::deleter );
            return static_cast<CData<T>*>(data)->Data;
        }
    }
    template<typename T>
    operator T*() { return &(T&)(*this); }
};

#define _0_ CFakeArgument()