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 часть реализщации
};

KO>>Ну, возможно, я ошибаюсь, но я подумал, что это просто пример, потому и названия смысла не имеют. Косвенно это подтверждается тем, что все имена имеющие отношения к сути вопроса, выглядят более понятно: AddRef/Release/mRefCount/mInternalImpl. Да и вообще, это обычное дело на форумах.

// Класс с типом type, являющимся ссылкой:
struct SomeClassWithReferenceType {
    typedef int& type;
};

// Просто какой-то класс, без ссылок:
struct SomeClass {
    typedef int type;
};

// И дальше описание какого-нибудь шаблонного трюка на этой основе с уже осмысленными именами.
// ...

   #include "stack.h"  // используем интерфейс стека

   static char v [ stack_size ]; // "static" означает локальный 
                          // в данном файле\модуле

    static char * p = v; // стек внчала пуст

    void push( char c)
    {
       ....

void f()
{

class complex
{
   double re, im;

void f()
{
   complex a = 2.3;
   complex b = 1 / a;
   complex c = a + b * complex( 1, 2.3 );

class shape
{
...
    kind k;

AF>>Топикстартеру нужно было бы назвать "mA" как "mData", тогда бы это не вызвало такой реакции

template<class T>
struct AddReference { typedef T& type; };

if( void* ptr = f() ) { // и не стал придумывать ничего сложнее ptr и f, хотя и мог
    // ...
}

Если уж дотрахиваться до таких мелочей, то надо и на переполнение проверять)