Библиотека COM (OLE Automation). Часть 1 - ArraySort (String)

//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;
}