class Class1Impl
{
    int mA;
    int mRefCount;

public:
    Class1Impl(): mA(0), mRefCount(1)
    {
        printf("Class1Impl::Class1Impl()\n");
    }

    virtual ~Class1Impl()
    {
        printf("~Class1Impl::Class1Impl()\n");
    }

    virtual void AddRef()
    { 
        mRefCount++; 
    }

    virtual void Release()
    { 
        mRefCount--; 
        if (mRefCount <= 0) 
            delete this; 
    }

    virtual void SetParamAImpl(int a)
    {
        mA = a;
    }

    virtual int GetParamAImpl() const
    {
        return mA;
    }
};

class Class1
{
    Class1Impl* mInternalImpl;

public:
    Class1()
    {
        mInternalImpl = new Class1Impl;
    }

    Class1(const Class1& other): mInternalImpl(other.mInternalImpl)
    {
        if (mInternalImpl)
            mInternalImpl->AddRef();
    }

    virtual ~Class1()
    {
        if (mInternalImpl)
            mInternalImpl->Release();
    }

    virtual bool operator == (const Class1 & other) const
    {
        return mInternalImpl == other.mInternalImpl;
    }

    virtual bool operator != (const Class1 & other) const
    {
        return mInternalImpl != other.mInternalImpl;
    }

    virtual Class1 & operator = (const Class1 & other)
    {
        if (mInternalImpl)
            mInternalImpl->Release();

        mInternalImpl = other.mInternalImpl;

        if (mInternalImpl)
            mInternalImpl->AddRef();

        return *this;
    }

    virtual void SetParamA(int a)
    {
        if (mInternalImpl)
            mInternalImpl->SetParamAImpl(a);
    }

    virtual int GetParamA() const
    {
        int result = 0;

        if (mInternalImpl)
            result = mInternalImpl->GetParamAImpl();

        return result;
    }
};

int _tmain(int argc, _TCHAR* argv[])
{
    Class1 a;
    Class1 b;
    Class1 c;
    a = c;

    printf("abc!\n");

    return 0;
}

GC>class Class1Impl
GC>{
GC>    int mA;
GC>    int mRefCount;

GC>public:
GC>    Class1Impl(): mA(0), mRefCount(1)
GC>    {
GC>        printf("Class1Impl::Class1Impl()\n");
GC>    }

GC>    virtual ~Class1Impl()
GC>    {
GC>        printf("~Class1Impl::Class1Impl()\n");
GC>    }

GC>    virtual void AddRef()
GC>    { 
GC>        mRefCount++; 
GC>    }

GC>    virtual void Release()
GC>    { 
GC>        mRefCount--; 
GC>        if (mRefCount <= 0) 
GC>            delete this; 
GC>    }

GC>    virtual void SetParamAImpl(int a)
GC>    {
GC>        mA = a;
GC>    }

GC>    virtual int GetParamAImpl() const
GC>    {
GC>        return mA;
GC>    }
GC>};

GC>class Class1
GC>{
GC>    Class1Impl* mInternalImpl;

GC>public:
GC>    Class1()
GC>    {
GC>        mInternalImpl = new Class1Impl;
GC>    }

GC>    Class1(const Class1& other): mInternalImpl(other.mInternalImpl)
GC>    {
GC>        if (mInternalImpl)
GC>            mInternalImpl->AddRef();
GC>    }

GC>    virtual ~Class1()
GC>    {
GC>        if (mInternalImpl)
GC>            mInternalImpl->Release();
GC>    }

GC>    virtual bool operator == (const Class1 & other) const
GC>    {
GC>        return mInternalImpl == other.mInternalImpl;
GC>    }

GC>    virtual bool operator != (const Class1 & other) const
GC>    {
GC>        return mInternalImpl != other.mInternalImpl;
GC>    }

GC>    virtual Class1 & operator = (const Class1 & other)
GC>    {
GC>        if (mInternalImpl)
GC>            mInternalImpl->Release();

GC>        mInternalImpl = other.mInternalImpl;

GC>        if (mInternalImpl)
GC>            mInternalImpl->AddRef();

GC>        return *this;
GC>    }

GC>    virtual void SetParamA(int a)
GC>    {
GC>        if (mInternalImpl)
GC>            mInternalImpl->SetParamAImpl(a);
GC>    }

GC>    virtual int GetParamA() const
GC>    {
GC>        int result = 0;

GC>        if (mInternalImpl)
GC>            result = mInternalImpl->GetParamAImpl();

GC>        return result;
GC>    }
GC>};

GC>int _tmain(int argc, _TCHAR* argv[])
GC>{
GC>    Class1 a;
GC>    Class1 b;
GC>    Class1 c;
GC>    a = c;

GC>    printf("abc!\n");

GC>    return 0;
GC>}
GC>

Class1 a;
a = a;

public:
    Class1() : mInternalImpl(new Class1Impl) {}

Class1 a;
a = a;

    int mRefCount;
    virtual void AddRef()
    { 
        mRefCount++; 
    }

struct A
{
//....
};

//...

void someFunc()
{
    boost::shared_ptr<A> sa(new A());
    boost::shared_ptr<A> sb(sa.get()); // Будет двойное удаление A
//...
}

// хедер MyClass.h
DECLARE_PIMPL( MyClass )
    METHOD( type1, Method1 )
    METHOD1( type2, Method2, arg1_t )
    //....
END_OF_PIMPL()

//  хедер MyClassImpl.h
class MyClass::MyClassimpl {
public:
#include<BeginImpl.h>
#include "MyClass.h"
#include<EndImpl.h>
private:
// тут, собственно private часть реализщации
};