Создание Клиента на С++ для подключения СОМ-надстройки

//mycom.h
#ifndef _my__dynamiclinking2_mycom_h_
#define _my__dynamiclinking2_mycom_h_
 
#include <windowsx.h>
#include <iostream>
#include <initguid.h>
/* in oleview.exe
    [
      odl,
      uuid(8465DED5-1F50-4A34-B0BD-D4379FDDE618),
      dual,
      nonextensible,
      oleautomation
    ]
    interface IVBA : IDispatch {
        [id(0x00000001), helpstring("Array sort")]
        HRESULT ArraySort(
                        [in, out] VARIANT* array_in_out, 
                        [in, optional, defaultvalue(0)] VARIANT_BOOL sort_order, 
                        [in, optional, defaultvalue(-1)] long key_1, 
                        [in, optional, defaultvalue(-1)] long key_2, 
                        [in, optional, defaultvalue(-1)] long key_3, 
                        [in, optional, defaultvalue(0)] long sort_orientation, 
                        [in, optional, defaultvalue(0)] VARIANT_BOOL delete_duplicates, 
                        [in, optional, defaultvalue(0)] VARIANT_BOOL out_array_index, 
                        [in, out, optional, defaultvalue(0)] VARIANT* index_array_out);
    };
    */
 
DEFINE_GUID( IID_IVBA,             
             0x8465ded5,0x1f50,0x4a34,0xb0,0xbd,0xd4,0x37,0x9f,0xdd,0xe6,0x18);
 
class IVBA  : public IDispatch
{
public:
    IVBA();
    virtual ~IVBA();
    STDMETHOD(ArraySort) (VARIANT*)  PURE;
};
 
#endif

#include <vector>
#include <windows.h>
#include <comdef.h>
#include <stdio.h>
 
#include <my__dynamiclinking2/mycom.h>
// #import "C:\BedvitCOMx32.dll" - with TypeLib
 
#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cstring>
 
using namespace std;
 
void fillVariant(VARIANT& varIn, BSTR *srcArray, int srcArrayLen)
{
    VARIANT *variantArray = &varIn;
    VariantInit(variantArray);
 
    SAFEARRAYBOUND aDim[1]; 
    aDim[0].lLbound = 0; 
    aDim[0].cElements = srcArrayLen;
 
    SAFEARRAY* sa = SafeArrayCreate(VT_BSTR, 1, aDim);
    if (sa)
    {    
        BSTR* dwArray = NULL;
        SafeArrayAccessData(sa, (void**)&dwArray);
 
        for(int i = 0; i < srcArrayLen; i++)
        {
            // note: passing ownership, NOT making a copy
            dwArray[i] = srcArray[i];
            std::wcout << dwArray[i] << endl;
        }
 
        SafeArrayUnaccessData(sa);
 
        variantArray->vt = VT_ARRAY|VT_BSTR;
        variantArray->parray = sa;
    }
}
 
BSTR foo(const char* s) {
  return _bstr_t(s).Detach();
}
 
int main( int argc, char *argv[] )  {
   cout << "Initializing COM" << endl;
 
   if ( FAILED( CoInitialize( NULL )))
   {
      cout << "Unable to initialize COM" << endl;
      return -1;
   }
 
   char* szProgID = "BedvitCOM.VBA";
   WCHAR  szWideProgID[128];
   CLSID  clsid;
   long lLen = MultiByteToWideChar( CP_ACP,
                        0,
                        szProgID,
                        strlen( szProgID ),
                        szWideProgID,
                        sizeof( szWideProgID ) );
 
   szWideProgID[ lLen ] = '\0';
   HRESULT hr = ::CLSIDFromProgID( szWideProgID, &clsid );
   if ( FAILED( hr ))
   {
      cout.setf( ios::hex, ios::basefield );
      cout << "Unable to get CLSID from ProgID. HR = " << hr << endl;
      return -1;
   }
//////
// https://www.rsdn.org/article/com/introcom.xml
    
   IClassFactory* pCF;
   // Получить фабрику классов для класса Math
   hr = CoGetClassObject( clsid,
                          CLSCTX_INPROC,
                          NULL,
                          IID_IClassFactory,
                          (void**) &pCF );
   if ( FAILED( hr ))
   {
      cout.setf( ios::hex, ios::basefield );
      cout << "Failed to GetClassObject server instance. HR = " << hr << endl;
      return -1;
   }
 
   // с помощью фабрики классов создать экземпляр
   // компонента и получить интерфейс IUnknown.
   IUnknown* pUnk;
   hr = pCF->CreateInstance( NULL, IID_IUnknown, (void**) &pUnk );
 
   // Release the class factory
   pCF->Release();
 
   if ( FAILED( hr ))
   {
      cout.setf( ios::hex, ios::basefield );
      cout << "Failed to create server instance. HR = " << hr << endl;
      return -1;
   }
 
   cout << "Instance created" << endl;
 
/////// 
    vector<char*> v;
    v={ "11", "1", "2", "8", "7" };
    
    BSTR *theArray = new BSTR[5];
      
    auto it { v.begin() };  // получаем итератор
    int i=0;
    //while(it!= v.end())    // пока не дойдем до конца
    for(auto it{begin(v)}; it != end(v); it++ )
    {
        
        theArray[i] = foo(*it);
        //++iter;
        ++i;
    }
 
    VARIANT vArray;
    fillVariant(vArray, theArray, 5);
////
    
   IVBA* pVBA = NULL;
   hr = pUnk->QueryInterface( IID_IVBA, (LPVOID*)&pVBA );
   pUnk->Release();
   if ( FAILED( hr ))
   {
      cout << "QueryInterface() for IVBA failed" << endl;
      return -1;
   }
  
/////
   pVBA->ArraySort( &vArray );      // [in, out]   
///// read vArray
 
    LPCWSTR pValsOut;   
    hr = SafeArrayAccessData(vArray.parray, (void **)&pValsOut); // direct access to SA memory
    if (SUCCEEDED(hr))
    {
      long lowerBound, upperBound;  // get array bounds
      SafeArrayGetLBound(vArray.parray, 1 , &lowerBound);
      SafeArrayGetUBound(vArray.parray, 1, &upperBound);
     
      long cnt_elements = upperBound - lowerBound + 1; 
      
      long ix=0;      
      for (long i = 0; i < cnt_elements; ++i)  // iterate through returned values
        {  
            LPCWSTR lVar;
            hr= SafeArrayGetElement(vArray.parray, &ix, &lVar); 
            wcout << lVar << endl;
            ix++;
        }
        
      //for(auto& it : Var.parray) cout << "el. " << pVals[i] << endl;      
                
      SafeArrayUnaccessData(vArray.parray);
    }
    
    // don't forget to free memory when done!
    // note: the VARIANT owns the BSTRs, so DON'T free them!
    VariantClear(&vArray);
    delete[] theArray;
    
/////
   cout << "Releasing instance" << endl;
   pVBA->Release();
 
   cout << "Shuting down COM" << endl;
   CoUninitialize();
 
   return 0;
}

_variant_t disp(pBedvitComVBADisp.GetInterfacePtr());

    hr = pDisp->Invoke(dispID, IID_NULL, LOCALE_NEUTRAL, autoType, &dp, pvResult, NULL, NULL);// Make the call!
    if (FAILED(hr)) {
        va_end(marker);
        delete[] pArgs;
        return hr;
    }

     std::cout  <<  "pvResult" << std::endl;
    BSTR* resarr = NULL;
    hr = SafeArrayAccessData(array.parray, (void HUGEP**) & resarr);//открываем массив
    if (FAILED(hr)) {
        return hr;
    }
    {
        for (long i = 0; i < 3; i++){
            std::wcout  <<  resarr[i] << std::endl; 
        }
    }
    hr = SafeArrayUnaccessData(array.parray); //закрываем массив
    if (FAILED(hr)) {
        return hr;
    }

if (cmd==DISPATCH_PROPERTYPUT) {
    DISPID dispidNamed=DISPID_PROPERTYPUT;   /* <--- PROBLEM LINE here */
    dispParams.cNamedArgs=1;
    dispParams.rgdispidNamedArgs=&dispidNamed;
}

#include <iostream>
 
  //COM
#include "comdef.h"
#include "oleacc.h"
 
 
HRESULT RunCom()
{
    IDispatchPtr    pBedvitComVBADisp = NULL;
    HRESULT hr = 0;
    GUID guid;
    hr = IIDFromString(L"{7a65494f-2a91-415c-9ff6-38f6611675ce}", &guid);   //IVBA
    if (FAILED(hr)) { 
        return hr;
    }
    hr = CoCreateInstance(guid, NULL, CLSCTX_INPROC_SERVER, IID_IDispatch, (void**)&pBedvitComVBADisp);
    if (FAILED(hr)) { 
        return hr;
    }
    
    const wchar_t* ptName = L"InStr";  
 
    DISPID dispidNamed = DISPID_PROPERTYPUT;
    DISPID dispID;
    hr = pBedvitComVBADisp->GetIDsOfNames(IID_NULL, (LPOLESTR*)&ptName, 1, LOCALE_NEUTRAL, &dispID );// Get DISPID for name passed...
    if (FAILED(hr)) {
        return hr;
    } 
    ////////////////////////////////// dp  
    
    _bstr_t StringIn(L"tofind");
    _bstr_t StringFindin(L"in"); 
    // IN REVERSED ORDER
    _variant_t pvars[2];
     pvars[0]= StringFindin;
     pvars[1]= StringIn;
     
    DISPPARAMS dp = { pvars, NULL, 2, 0 };// Variables used...
         
    /////////////////////////////////  varResult;
 
    VARIANT pvResult;
    VariantInit(&pvResult);
    pvResult.vt = VT_I4;    
    
    EXCEPINFO excepinfo;    //struct with m_BSTR that is OLECHAR
    memset(&excepinfo, 0, sizeof(excepinfo));
    UINT nArgErr = (UINT)-1;
    
    _variant_t disp(pBedvitComVBADisp.GetInterfacePtr() ); // disp.pdispVal
    
     hr = disp.pdispVal->Invoke(dispID, IID_NULL, LOCALE_NEUTRAL, DISPATCH_METHOD, &dp, &pvResult, &excepinfo, &nArgErr);// Make the call!
    if (FAILED(hr)) {
        std::cout << "err Invoke" << std::endl;
        MessageBoxW(NULL, _com_error(hr).ErrorMessage(), excepinfo.bstrDescription, MB_ICONERROR | MB_TOPMOST);
        return hr;
    }
    std::cout  <<  "\n res:" << pvResult.lVal << std::endl;
    VariantClear(&pvResult);
    
    return 0;
}
 
  
int main()
{
    HRESULT hr = S_OK;
    hr = OleInitialize(NULL);
    if (FAILED(hr)) {
        printf("Failed to init COM.");
        return -1;
    }
    if (FAILED(hr)) {
        MessageBoxW(NULL, _com_error(hr).ErrorMessage(), L"Error", MB_ICONERROR | MB_TOPMOST);
        return hr;
    }
    hr = RunCom();
    if (FAILED(hr)) {
        MessageBoxW(NULL, _com_error(hr).ErrorMessage(), L"Error", MB_ICONERROR | MB_TOPMOST);
    }
    OleUninitialize();
    return hr;
}