🚀 go-pugleaf

When I upgrade my BCB6 code to BDS2006, the project code compile fail
with E2034 in using STL mem_fun function.
Error Message:
[C++ Error] CAutoLookup.h(144): E2034 Cannot convert
'_Vector_iterator<TCNameCodeInfo,allocator<TCNameCodeInfo> >' to
'TCNameCodeInfo *'
  Full parser context
    CAutoLookup.h(132): decision to instantiate: void
CAutoLookup<TCNameCodeInfoList,int (TCNameCodeInfo::*)(),string
(TCNameCodeInfo::*)()>::FillComboBox(TComboBox *)
    --- Resetting parser context for instantiation...
    CPublicFunc.cpp(23): #include
E:\CVSWork\products\openboss\\public_win\util\CAutoLookup.h
    CAutoLookup.h(113): class CAutoLookup<TypeList,FnGetCode,FnGetName>
    CAutoLookup.h(132): parsing: void
CAutoLookup<TCNameCodeInfoList,int (TCNameCodeInfo::*)(),string
(TCNameCodeInfo::*)()>::FillComboBox(TComboBox *)

my Code:CAutoLookup.h

#ifndef __C_AUTO_LOOKUP_H__
#define __C_AUTO_LOOKUP_H__

#ifndef __cplusplus
	#error CAutoLookup requires C++ compilation (use a .cpp suffix)
#endif

#include <cstdio>
#include <cstdlib>
#include <string>
#include <algorithm>
#include <functional>
#include <vector>
using namespace std;

#ifdef INC_VCL
    #include <vcl.h>
    #include <StdCtrls.hpp>
#endif

template <class TypeList>
class CBasicLookup
{
public:
    typedef auto_ptr<CBasicLookup<TypeList> > safe_ptr;

    CBasicLookup(TypeList &vDataList) : m_vNameCodeList(vDataList)
    {
    };

    ~CBasicLookup(void)
    {
    };

    CBasicLookup& operator=(const CBasicLookup &rhs)
    {
        if (&rhs != this)
        {
            m_vNameCodeList = rhs.m_vNameCodeList;
        }

        return (*this);
    };

    void SetSourceList(const TypeList &vDataList)
    {
        m_vNameCodeList = vDataList;
        return;
    };

    const TypeList& GetSourceList(void) const
    {
        return (m_vNameCodeList);
    };

#ifdef INC_VCL
    virtual void FillComboBox(TComboBox *pComboBox) = 0;

    virtual void FillListBox(TListBox *pListBox) = 0;
#endif

    virtual int CNameToCodeID(const char *pszCName) = 0;

    virtual int NameToCode(const char *pszCName) = 0;

    virtual const char* CodeIDToCName(int nCodeID) = 0;

    virtual const char* CodeToName(int nCodeID) = 0;

protected:
    TypeList    m_vNameCodeList;

protected:
    CBasicLookup(void);
};

template <class TypeList, typename FnGetCode, typename FnGetName>
class CAutoLookup : public CBasicLookup<TypeList>
{
public:
    CAutoLookup(TypeList &vDataList, FnGetCode pGetCode, FnGetName
pGetName) :
        CBasicLookup<TypeList>(vDataList),
        m_pGetCode(pGetCode),
        m_pGetName(pGetName)
    {
    };

    virtual ~CAutoLookup(void)
    {
    };

#ifdef INC_VCL
    void FillComboBox(TComboBox *pComboBox)
    {
        if (NULL == pComboBox)
        {
            return;
        }

        TypeList::iterator IndexPtr = m_vNameCodeList.begin();
        TypeList::iterator EndPtr   = m_vNameCodeList.end();

        for (; IndexPtr != EndPtr; ++IndexPtr)
        {
            const char *Result = MergeCodeName(
                mem_fun(m_pGetCode)(IndexPtr),
                mem_fun(m_pGetName)(IndexPtr).c_str()
            );
            pComboBox->Items->Add(Result);
        }

        if (pComboBox->Items->Count > 0)
        {
            pComboBox->ItemIndex = 0;
        }

        return;
    };

    void FillListBox(TListBox *pListBox)
    {
        if (NULL != pListBox)
        {
            TypeList::iterator IndexPtr = NULL;
            TypeList::iterator EndPtr   = m_vNameCodeList.end();

            for (IndexPtr = m_vNameCodeList.begin(); IndexPtr !=
EndPtr; ++IndexPtr)
            {

pListBox->Items->Add(MergeCodeName(mem_fun(m_pGetCode)(IndexPtr),
mem_fun(m_pGetName)(IndexPtr).c_str()));
            }
        }

        return;
    };
#endif

    int CNameToCodeID(const char *pszCName)
    {
        TypeList::iterator IndexPtr = NULL;
        TypeList::iterator EndPtr   = m_vNameCodeList.end();

        for (IndexPtr = m_vNameCodeList.begin(); IndexPtr != EndPtr;
++IndexPtr)
        {
            if (strcmpi(MergeCodeName(mem_fun(m_pGetCode)(IndexPtr),
mem_fun(m_pGetName)(IndexPtr).c_str()), pszCName) == 0)
            {
                return (mem_fun(m_pGetCode)(IndexPtr));
            }
        }

        return (atoi(pszCName));
    };

    int NameToCode(const char *pszCName)
    {
        TypeList::iterator IndexPtr = NULL;
        TypeList::iterator EndPtr   = m_vNameCodeList.end();

        for (IndexPtr = m_vNameCodeList.begin(); IndexPtr != EndPtr;
++IndexPtr)
        {
            if
(strcmpi(MergeCodeName(mem_fun(m_pGetName)(IndexPtr).c_str()),
pszCName) == 0)
            {
                return (mem_fun(m_pGetCode)(IndexPtr));
            }
        }

        return (atoi(pszCName));
    };

    const char* CodeIDToCName(int nCodeID)
    {
        static char szCName[128] = "";

        memset(szCName, 0, sizeof(szCName));
        itoa(nCodeID, szCName, 10);

        TypeList::iterator IndexPtr = NULL;
        TypeList::iterator EndPtr   = m_vNameCodeList.end();

        for (IndexPtr = m_vNameCodeList.begin(); IndexPtr != EndPtr;
++IndexPtr)
        {
            if (mem_fun(m_pGetCode)(IndexPtr) == nCodeID)
            {
                strncpy(szCName,
MergeCodeName(mem_fun(m_pGetCode)(IndexPtr),
mem_fun(m_pGetName)(IndexPtr).c_str()), (sizeof(szCName) - 1));
                break;
            }
        }

        return (szCName);
    };

    const char* CodeToName(int nCodeID)
    {
        static char szCName[128] = "";

        memset(szCName, 0, sizeof(szCName));

        TypeList::iterator IndexPtr = NULL;
        TypeList::iterator EndPtr   = m_vNameCodeList.end();

        for (IndexPtr = m_vNameCodeList.begin(); IndexPtr != EndPtr;
++IndexPtr)
        {
            if (mem_fun(m_pGetCode)(IndexPtr) == nCodeID)
            {
                strncpy(szCName,
MergeCodeName(mem_fun(m_pGetName)(IndexPtr).c_str()), (sizeof(szCName)
- 1));
                break;
            }
        }

        return (szCName);
    };

protected:
    CAutoLookup(void);

    const char* MergeCodeName(int nCodeID, const char *pszCName)
    {
        static char szResult[128] = "";
        memset(szResult, 0, sizeof(szResult));

        if (NULL != pszCName)
        {
            snprintf(szResult, (sizeof(szResult) - 1), "[%d] %s",
nCodeID, pszCName);
        }

        return (szResult);
    };

    const char* MergeCodeName(const char *pszCName)
    {
        static char szResult[128] = "";
        memset(szResult, 0, sizeof(szResult));

        if (NULL != pszCName)
        {
            snprintf(szResult, (sizeof(szResult) - 1), "%s", pszCName);
        }

        return (szResult);
    };

private:
    FnGetCode     m_pGetCode;
    FnGetName     m_pGetName;
};

template <class TypeList, typename FnGetCode, typename FnGetName>
CBasicLookup<TypeList>* CreateAutoLookup(TypeList& vDataList, FnGetCode
fnGetCode, FnGetName fnGetName)
{
    return (new CAutoLookup<TypeList, FnGetCode, FnGetName>(vDataList,
fnGetCode, fnGetName));
}


#endif //__C_AUTO_LOOKUP_H__