Excel и C++

HRESULT AutoWrap(int autoType, VARIANT *pvResult, IDispatch *pDisp,LPOLESTR ptName, int cArgs...)
{
    if(!pDisp) return E_FAIL;
 
    va_list marker;
    va_start(marker, cArgs);
 
    DISPPARAMS dp = { NULL, NULL, 0, 0 };
    DISPID dispidNamed = DISPID_PROPERTYPUT;
    DISPID dispID;
    char szName[200];
 
    // Convert down to ANSI
    WideCharToMultiByte(CP_ACP, 0, ptName, -1, szName, 256, NULL, NULL);
 
    // Get DISPID for name passed...
    HRESULT hr = pDisp->GetIDsOfNames(IID_NULL, &ptName, 1, LOCALE_USER_DEFAULT, &dispID);
    if(FAILED(hr)) {
        return hr;
    }
    // Allocate memory for arguments...
    VARIANT *pArgs = new VARIANT[cArgs+1];
    // Extract arguments...
    for(int i=0; i<cArgs; i++) {
        pArgs[i] = va_arg(marker, VARIANT);
    }
 
    // Build DISPPARAMS
    dp.cArgs = cArgs;
    dp.rgvarg = pArgs;
 
    // Handle special-case for property-puts!
    if(autoType & DISPATCH_PROPERTYPUT) {
        dp.cNamedArgs = 1;
        dp.rgdispidNamedArgs = &dispidNamed;
    }
 
    // Make the call!
    hr = pDisp->Invoke(dispID, IID_NULL, LOCALE_SYSTEM_DEFAULT, autoType, &dp, pvResult, NULL, NULL);
    if(FAILED(hr)) {
        return hr;
    }
 
    // End variable-argument section...
    va_end(marker);
 
    delete [] pArgs;
 
    return hr;
}
 
#define BREAK_ON_FAIL(x) if (FAILED(hr = x)) break;
 
struct xls_t
{
    VARIANT app;
    VARIANT wbs;
    VARIANT wb;
    VARIANT wss;
    VARIANT ws;
};
 
HRESULT proc_beg(const std::string &path, xls_t * const xls, bool visible)
{
    HRESULT hr;
 
    VARIANT x;
    VARIANT _path;
 
    VariantInit(&xls->app);
    VariantInit(&xls->wbs);
    VariantInit(&xls->wb);
    VariantInit(&_path);
    VariantInit(&xls->wss);
    VariantInit(&xls->ws);
 
    while (true) {
 
    CoInitialize(NULL);
 
    CLSID clsid;
    BREAK_ON_FAIL(CLSIDFromProgID(L"Excel.Application", &clsid))
 
    xls->app.vt = VT_DISPATCH;
    xls->app.pdispVal = 0;
    BREAK_ON_FAIL(CoCreateInstance(clsid, NULL, CLSCTX_LOCAL_SERVER, IID_IDispatch, (void **)&xls->app.pdispVal))
 
    x.vt = VT_I4;
    x.lVal = visible;
    BREAK_ON_FAIL(AutoWrap(DISPATCH_PROPERTYPUT, NULL, xls->app.pdispVal, L"Visible", 1, x))
 
    BREAK_ON_FAIL(AutoWrap(DISPATCH_PROPERTYGET, &xls->wbs, xls->app.pdispVal, L"Workbooks", 0))
 
    if (path.size())
    {
        _path.vt = VT_BSTR;
        _path.bstrVal = SysAllocString(str_to_wstr(path).c_str());
        BREAK_ON_FAIL(AutoWrap(DISPATCH_METHOD, &xls->wb, xls->wbs.pdispVal, L"Open", 1, _path))
        VariantClear(&_path);
    }
    else
    {
        BREAK_ON_FAIL(AutoWrap(DISPATCH_METHOD, &xls->wb, xls->wbs.pdispVal, L"Add", 0))
    }
 
    BREAK_ON_FAIL(AutoWrap(DISPATCH_PROPERTYGET, &xls->wss, xls->wb.pdispVal, L"Worksheets", 0))
 
    x.lVal = 1;
    BREAK_ON_FAIL(AutoWrap(DISPATCH_PROPERTYGET, &xls->ws, xls->wss.pdispVal, L"Item", 1, x))
 
    break;}
 
    return hr;
}
 
HRESULT proc_end(HRESULT hr, xls_t * const xls, bool save, bool close)
{
    if (!FAILED(hr))
    {
        while (true) {
 
        if (save)
        {
            BREAK_ON_FAIL(AutoWrap(DISPATCH_METHOD, NULL, xls->wb.pdispVal, L"Save", 0))
        }
 
        if (close)
        {
            BREAK_ON_FAIL(AutoWrap(DISPATCH_METHOD, NULL, xls->wb.pdispVal, L"Close", 0))
        }
 
        break;}
    }
 
    VariantClear(&xls->app);
    VariantClear(&xls->wbs);
    VariantClear(&xls->wb);
    VariantClear(&xls->wss);
    VariantClear(&xls->ws);
 
    return hr;
}
 
HRESULT set_ws_no(xls_t * const xls, int no)
{
    HRESULT hr;
 
    VARIANT x;
 
    while (true) {
 
    x.vt = VT_I4;
    x.lVal = no;
    BREAK_ON_FAIL(AutoWrap(DISPATCH_PROPERTYGET, &xls->ws, xls->wss.pdispVal, L"Item", 1, x))
 
    break;}
 
    return hr;
}
 
HRESULT write(VARIANT ws, int _r, int _c, const std::string &_x)
{
    HRESULT hr;
 
    VARIANT cell;
    VARIANT r;
    VARIANT c;
    VARIANT x;
 
    VariantInit(&cell);
    r.vt = VT_I4;
    c.vt = VT_I4;
    VariantInit(&x);
 
    while (true) {
 
    r.lVal = _r;
    c.lVal = _c;
    BREAK_ON_FAIL(AutoWrap(DISPATCH_PROPERTYGET, &cell, ws.pdispVal, L"Cells", 2, c, r))
 
    x.vt = VT_BSTR;
    x.bstrVal = SysAllocString(str_to_wstr(_x).c_str());
    BREAK_ON_FAIL(AutoWrap(DISPATCH_PROPERTYPUT, NULL, cell.pdispVal, L"Value", 1, x))
 
    break;}
 
    VariantClear(&cell);
    VariantClear(&x);
 
    return hr;
}
 
HRESULT write(VARIANT ws, int _r, int _c, const double &_x)
{
    HRESULT hr;
 
    VARIANT cell;
    VARIANT r;
    VARIANT c;
    VARIANT x;
 
    VariantInit(&cell);
    r.vt = VT_I4;
    c.vt = VT_I4;
    x.vt = VT_R8;
 
    while (true) {
 
    r.lVal = _r;
    c.lVal = _c;
    BREAK_ON_FAIL(AutoWrap(DISPATCH_PROPERTYGET, &cell, ws.pdispVal, L"Cells", 2, c, r))
 
    x.dblVal = _x;
    BREAK_ON_FAIL(AutoWrap(DISPATCH_PROPERTYPUT, NULL, cell.pdispVal, L"Value", 1, x))
 
    break;}
 
    VariantClear(&cell);
 
    return hr;
}
 
...
 
                    HRESULT hr;
                    xls_t xls;
 
                    hr = proc_beg(path, &xls);
                    if (FAILED(hr))
                    {
                        proc_end(hr, &xls);
                    }
                    else
                    {
                        while (true) {
 
                        BREAK_ON_FAIL(write(xls.ws, 1, 1, "zzz"))
 
                        break;}
 
                        proc_end(hr, &xls);
                    }