Convert BSTR HUGEP * to a wchar_t* or char *

Hello I want to be able to convert a pointer that is defined as a BSTR
HUGEP *pbstr to a wchar_t * or a char* pointer but I am having some
issues. First of all I want to make sure I understand BSTR HUGEP * -<
to me this means I have a BSTR pointer that is cable of 64 bit but I'm
not quiet sure . Anyway I have the code working to get the elements
from the safe array but I want to convert the array value to a char *
or a wchar_t in a defined structure before I go back to the calling
program. I can copy pbstr[0] into a wchar_t data[300] but Id rather
use wchar_t * instead and I am concerned that the wcscopy looks right
at the suface but since a BSTR is not a true Wchar_t then this concerns
me as well - Any ideas?

Here is my code

int u_dll_ims21_call(wchar_t *TheConnectString, wchar_t *TheTable,
wchar_t *TheFields, wchar_t *ThePopupTitle, wchar_t *TheOrderBy,
wchar_t *TheWhereClause, wchar_t *ThePosition)
{
    // Now we will intilize COM

    HRESULT hr = CoInitialize(0);

    if(SUCCEEDED(hr))
    {
        _clsCat16Ptr ptrCat16(__uuidof(clsCat16)); //Smart pointer wrapper

        //_clsCat16 *IclsCat16 = NULL;
        //hr = CoCreateInstance(__uuidof (clsCat16),
        // NULL,
        // CLSCTX_INPROC_SERVER,
          // _uuidof (_clsCat16),
            // (void**) &IclsCat16);

    // if(SUCCEEDED(hr))
    // {

            BSTR bstrTheConnectString= SysAllocString(TheConnectString);
            BSTR bstrTheTable = SysAllocString(TheTable);
            BSTR bstrTheFields= SysAllocString(TheFields);
            BSTR bstrThePopupTitle = SysAllocString(ThePopupTitle);
            BSTR bstrTheOrderBy = SysAllocString(TheOrderBy);
            BSTR bstrTheWhereClause = SysAllocString(TheWhereClause);
            BSTR bstrThePosition = SysAllocString(ThePosition);

            //Create a SafeArray
            SAFEARRAY FAR* RTNArray = NULL;

        // _bstr_t bvalue = ptrCat16->Popup(&bstrTheConnectString,
&bstrTheTable,
        // &bstrTheFields, &bstrThePopupTitle,
        // &bstrTheOrderBy, &bstrTheWhereClause,
        // &bstrThePosition);

            short bvalue = ptrCat16->Popup(&bstrTheConnectString, &bstrTheTable,
                                             &bstrTheFields, &bstrThePopupTitle,
                                             &bstrTheOrderBy, &RTNArray, &bstrTheWhereClause,
                                             &bstrThePosition);

            if(bvalue == 0)
            {
                //Free all the bstrings //
                SysFreeString(bstrTheConnectString);
                SysFreeString(bstrTheTable);
                SysFreeString(bstrTheFields);
                SysFreeString(bstrThePopupTitle);
                SysFreeString(bstrTheOrderBy);
                SysFreeString(bstrTheWhereClause);
                SysFreeString(bstrThePosition);
                return 0;
            }
            //Pointer to the safe array that is returned from the VB call //
            BSTR HUGEP *pbstr;
            wchar_t data[300];
            wchar_t *arraylimit = NULL;
            // check to see if it is a one-dimensional or two-dimensional array
//
            if ( RTNArray->cDims != 1 )
            {
                //Lock the array //
                hr= SafeArrayLock(RTNArray);
                long ai[2];
                int lower1 = RTNArray->rgsabound[1].lLbound;
                int upper1 = RTNArray->rgsabound[1].cElements + lower1;
                //Loop through the row first
                for(int i = lower1; i < upper1; i++)
                {
                    ai[0]=i;
                    int lower0 = RTNArray->rgsabound[0].lLbound;
                    int upper0 = RTNArray->rgsabound[0].cElements + lower0;
                    //Now loop through each column in the row //
                    for(int j = lower0; j < upper0; j++)
                    {
                        ai[1]=j;
                        hr=SafeArrayPtrOfIndex(RTNArray, ai, (void HUGEP* FAR*)&pbstr);
                        if(SUCCEEDED(hr))
                        {
                            data[0] = L'\000';
                            wcscpy(data,pbstr[0]);
                            char* lpszText2 = _com_util::ConvertBSTRToString(pbstr[0]);

                        }
                    }
                }
                //Unlock the array //
                hr= SafeArrayUnlock(RTNArray);
                //Destroy the array //
                hr = SafeArrayDestroy(RTNArray);