Figured it out....

As it turns out the suggestion in MSDN to preface the function definition
with

template <class T>

works. I just wasn't putting it in the right place.

"Eric Margheim" <NOSPAM***eric@prism-grp.com***NOSPAM> wrote in message
news:%230Mo3chlGHA.4268@TK2MSFTNGP05.phx.gbl...
I have a smart pointer class that uses template functions that works fine
under VC6 but it not linking under VS2005.

1>TestGridToolkitView.obj : error LNK2019: unresolved external symbol "void
__cdecl PrismGCSmartPointer(class CPrismSmartPointer<class CDialog> &)"
(?PrismGCSmartPointer@@YAXAAV?$CPrismSmartPointer@VCDialog@@@@@Z) referenced
in function "protected: __thiscall
CTestGridToolkitView::CTestGridToolkitView(void)"
(??0CTestGridToolkitView@@IAE@XZ)
1>E:\PrismDevelopment\VS2005\TestGridToolkit\Debug\TestGridToolkit.exe :
fatal error LNK1120: 1 unresolved externals

I've found several articles about this but the solutions they suggest don't
work. Any thought. I've posted the header file below. There isn't
much in the .cpp file since the functions are inline.

template <class DataT>
class CPrismSmartPointer
{
private:
    class CData
    {
    public:
        CData(DataT* pDataT): m_dwRefCount(0), m_pDataT(pDataT)
        {
            AddRef();
        }

        ~CData()
        {
            Release();
        }

        void AddRef()
        {
            m_dwRefCount++;
        }

        DataT* Get()
        {
            return m_pDataT;
        }

        void Release()
        {
            if (!m_dwRefCount)
                    return;

            if (--m_dwRefCount == 0)
            {
                if (m_pDataT)
                {
                    delete m_pDataT;
                    m_pDataT = NULL;
                }

                delete this;
            }
        }

        DataT* m_pDataT;
        DWORD m_dwRefCount;
    };

    CData* m_pData;

public:
    CPrismSmartPointer(): m_pData(NULL)
    {
    }

    CPrismSmartPointer(bool bNew): m_pData( bNew ? new CData(new DataT) :
NULL)
    {
    }

    CPrismSmartPointer(int nNew): m_pData(nNew ? new CData(new DataT) :
NULL)
    {
    }

    CPrismSmartPointer(DataT* pDataT): m_pData(new CData(pDataT))
    {
    }

    ~CPrismSmartPointer()
    {
        if (m_pData)
            m_pData->Release();
    }

    CPrismSmartPointer(const DataT*& pDataT): m_pData(new CData(pDataT))
    {
    }

    CPrismSmartPointer(const CPrismSmartPointer<DataT>& other)
    {
        m_pData = other.m_pData;
        if (m_pData)
            m_pData->AddRef();
    }

    CPrismSmartPointer& operator=(const CPrismSmartPointer& other)
    {
        if (&other == this)
            return *this;
        if (m_pData)
            m_pData->Release();
        m_pData = other.m_pData;
        if (m_pData)
            m_pData->AddRef();
        return *this;
    }

    CPrismSmartPointer& operator=(DataT* pDataT)
    {
        if (m_pData)
        {
            if (m_pData->m_pDataT == pDataT)
                return *this;
        }
        if (m_pData)
            m_pData->Release();
        m_pData = pDataT ? new CData(pDataT) : NULL;
        return *this;
    }

    DataT& operator*() const
    {
        return *Get();
    }

    DataT* operator->() const
    {
        return Get();
    }

    DataT* Get() const
    {
        if (!m_pData)
            return NULL;
        return m_pData->m_pDataT;
    }

    operator DataT*()
    {
        return Get();
    }

    operator bool()
    {
        if (m_pData && m_pData->m_pDataT)
            return true;
        return false;
    }

    bool operator !()
    {
        return !operator bool();
    }

    friend bool operator==(const CPrismSmartPointer<DataT>& lhs,const
CPrismSmartPointer<DataT>& rhs);
    friend bool operator==(const CPrismSmartPointer<DataT>& other, const
DataT* pRhsT);
    friend bool operator==(const CPrismSmartPointer<DataT>& lhs, int nRhs);
    friend void PrismGCSmartPointer(CPrismSmartPointer<DataT>& pSP);
};

template<class DataT> inline bool operator==(const
CPrismSmartPointer<DataT>& lhs, const CPrismSmartPointer<DataT>& rhs)
{
    if (lhs.m_pData && rhs.m_pData)
        return (lhs.m_pData->m_pDataT == rhs.m_pData->m_pDataT);
    return false;
}

template<class DataT> inline bool operator==(const
CPrismSmartPointer<DataT>& lhs, const DataT* pRhsT)
{
    if (lhs->m_pData)
        return (lhs->m_pData->m_pDataT == pRhsT);
    return false;
}

template<class DataT> inline bool operator==(const
CPrismSmartPointer<DataT>& lhs, int nRhs)
{
    int nTemp = 0;
    if (lhs.m_pData)
    {
    if (lhs.m_pData->m_pDataT)
        nTemp = (int) (lhs.m_pData->m_pDataT);
    }
    return (nTemp == nRhs);
}

template<class DataT> inline void
PrismGCSmartPointer(CPrismSmartPointer<DataT>& pSP)
{
    pSP = NULL;
}