Блочное чтение файла Excel без сторонних библиотек

//---------------------------------------------------------------------------
 
#pragma hdrstop
#include <ole2.h>
#include <stdio.h>
#include <system.hpp>
#include <SysUtils.hpp>
#include <iostream>
 
 
// AutoWrap() - Automation helper function...
HRESULT AutoWrap(int autoType, VARIANT *pvResult, IDispatch *pDisp, LPOLESTR ptName, int cArgs...) {
    // Begin variable-argument list...
    va_list marker;
    va_start(marker, cArgs);
 
    if(!pDisp) {
        MessageBox(NULL, "NULL IDispatch passed to AutoWrap()", "Error", 0x10010);
        _exit(0);
    }
 
    // Variables used...
    DISPPARAMS dp = { NULL, NULL, 0, 0 };
    DISPID dispidNamed = DISPID_PROPERTYPUT;
    DISPID dispID;
    HRESULT hr;
    char buf[200];
    char szName[200];
 
    
    // Convert down to ANSI
    WideCharToMultiByte(CP_ACP, 0, ptName, -1, szName, 256, NULL, NULL);
    
    // Get DISPID for name passed...
    hr = pDisp->GetIDsOfNames(IID_NULL, &ptName, 1, LOCALE_USER_DEFAULT, &dispID);
    if(FAILED(hr)) {
        sprintf(buf, "IDispatch::GetIDsOfNames(\"%s\") failed w/err 0x%08lx", szName, hr);
        MessageBox(NULL, buf, "AutoWrap()", 0x10010);
        _exit(0);
        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)) {
        sprintf(buf, "IDispatch::Invoke(\"%s\"=%08lx) failed w/err 0x%08lx", szName, dispID, hr);
        MessageBox(NULL, buf, "AutoWrap()", 0x10010);
        _exit(0);
        return hr;
    }
    // End variable-argument section...
    va_end(marker);
    
    delete [] pArgs;
    
    return hr;
} 
//---------------------------------------------------------------------------
 
class Excel
{
public:
   Excel(String const& _filePath) : filePath(_filePath)
   {
          // Initialize COM for this thread...
   CoInitialize(NULL);
 
   // Get CLSID for our server...
   
   hr = CLSIDFromProgID(L"Excel.Application", &clsid);
 
   if(FAILED(hr)) {
 
      ::MessageBox(NULL, "CLSIDFromProgID() failed", "Error", 0x10010);
      return ;
   }
 
   // Start server and get IDispatch...
   
   hr = CoCreateInstance(clsid, NULL, CLSCTX_LOCAL_SERVER, IID_IDispatch, (void **)&pXlApp);
   if(FAILED(hr)) {
      ::MessageBox(NULL, "Excel not registered properly", "Error", 0x10010);
      return ;
   }
 
   // Make it visible (i.e. app.visible = 1)
   {
 
      VARIANT x;
      x.vt = VT_I4;
      x.lVal = 1;
      //AutoWrap(DISPATCH_PROPERTYPUT, NULL, pXlApp, L"Visible", 1, x);
   }
 
   // Get Workbooks collection
   
   {
      VARIANT result;
      VariantInit(&result);
      AutoWrap(DISPATCH_PROPERTYGET, &result, pXlApp, L"Workbooks", 0);
      pXlBooks = result.pdispVal;
   }
   
   {
      OLECHAR *sOleText=new OLECHAR[strlen(filePath.c_str())+1];
      mbstowcs(sOleText, filePath.c_str(), strlen(filePath.c_str())+1);
      VARIANT result;
      VariantInit(&result);
      VARIANT fname;
      fname.vt = VT_BSTR;
      fname.bstrVal=::SysAllocString(sOleText);
      AutoWrap(DISPATCH_METHOD, &result, pXlBooks, L"Open", 1, fname);
      pXlBook = result.pdispVal;
      ::SysFreeString(fname.bstrVal);
      delete sOleText;
   }
   // Get ActiveSheet object
   
   {
      VARIANT result;
      VariantInit(&result);
      AutoWrap(DISPATCH_PROPERTYGET, &result, pXlApp, L"ActiveSheet", 0);
      pXlSheet = result.pdispVal;
   }
 
    // Get Range from Sheet
   
   }
 
 
   void Matrix(String const& _location)
   {
      location = _location;
      
      OLECHAR *sOleText=new OLECHAR[location.Length()+1];
   mbstowcs(sOleText,location.c_str(),location.Length()+1);
 
   VARIANT parm;
   parm.vt = VT_BSTR;
   parm.bstrVal = ::SysAllocString(sOleText);
 
    //IDispatch *pXlRange; // Get Range from Sheet
   {
      VARIANT result;
      VariantInit(&result);
      AutoWrap(DISPATCH_PROPERTYGET, &result, pXlSheet, L"Range", 1, parm);
      VariantClear(&parm);
      pXlRange = result.pdispVal;
   }
      VariantClear(&var);
      AutoWrap(DISPATCH_PROPERTYGET, &var, pXlRange, L"Value", 0);
 
      pXlRange->Release();
      delete sOleText;
 
      SAFEARRAY* psa = var.parray;
      
      SafeArrayGetLBound(psa, 1, &startIndexR);
      SafeArrayGetUBound(psa, 1, &endIndexR);
      rows = endIndex - startIndex + 1;
      //std::cout << rows << '\n';
 
      long startIndex = 0, endIndex = 0;
      SafeArrayGetLBound(psa, 2, &startIndex);
      SafeArrayGetUBound(psa, 2, &endIndex);
      cols = endIndex - startIndex + 1;
      //std::cout << cols << '\n';
 
      if(FAILED(SafeArrayAccessData(psa, (void **) &pVar))) ::MessageBox(0, "failed 2", "error", 0);
      SafeArrayUnaccessData(psa);
 
      if(pVar[rows - 1].vt == VT_EMPTY)
      {
         for(int i = 0; i < rows; ++i)
         {
            if(pVar[i].vt == VT_EMPTY)
            {
               rows = i;
               break;
            }
         }   
      }
   }
 
   VARIANT& Element(int i, int j)
   {
      int realRows = endIndexR - startIndexR + 1;
      return (pVar + realRows * j)[i];   
   }
   
 
   ~Excel()
   {
      AutoWrap(DISPATCH_METHOD, NULL, pXlApp, L"Quit", 0);
      // Release references...
      //pXlRange->Release();
      pXlSheet->Release();
      pXlBooks->Release();
      pXlApp->Release();
 
      // Uninitialize COM for this thread...
      CoUninitialize();
   }
 
 
   int rows, cols;
private:
   String filePath, location;
   CLSID clsid;
   HRESULT hr;
   IDispatch *pXlApp;
   IDispatch *pXlBooks;
   IDispatch *pXlBook;
   IDispatch *pXlSheet;
   IDispatch *pXlRange;
   VARIANT var; // contains array
   VARIANT* pVar; //pointer to first element of array
   long startIndexR, endIndexR;
 
};
 
 
#pragma argsused
int main(int argc, char* argv[])
{
   // open excel file
   Excel exc("C:\\RZMsk25.DBF");
   
   int step = 3000;
   for(int i = 2; ; ++i)
   {
   // set matrix bounds
   String location = "a" + IntToStr(i);
   location += ":b" + IntToStr(i += step);
   
   // get matrix from excel file
   exc.Matrix(location);
   
   //std::cout << exc.rows << '\n';
   // if matrix contains only empty cells then exit
   if(exc.rows == 0) break;
   
   //std::cout << exc.Element(1, 0).vt << '\n';
   
   // loop on matrix elements
   for(int i = 0; i < exc.rows; ++i)
   {
      for(int j = 0; j < exc.cols; ++j)
      {
         //std::cout << exc.Element(i, j).vt << '\n';
         switch(exc.Element(i, j).vt)
         {
            case VT_R8:
            {
               std::cout << exc.Element(i, j).dblVal << '\n';
               //::MessageBox(0, FloatToStr(exc.Element(i, j).dblVal).c_str(), "VT_R8", 0);
               break;
            }
            case VT_BSTR:
            {
               char buf[1024];
               WideCharToMultiByte(CP_ACP, 0, exc.Element(i, j).bstrVal, -1, buf, sizeof(buf), 0, 0); 
               std::cout << buf << "  ";
               //::MessageBox(0, buf, "VT_BSTR", 0);
               break;
            }
            default:
            {
               ::MessageBox(0, IntToStr(exc.Element(i, j).vt).c_str(), "", 0);
            }
         }// switch
      }// for j
   } // for i
   }
   
   std::cin.sync();
   std::cin.get();                                                                   
   return 0;
}
//---------------------------------------------------------------------------

void __fastcall TForm1::Button1Click(TObject *Sender)
{
//Открыли Ексель
  Variant app, books, book, sheet, Rang, vCell;
  app = CreateOleObject("Excel.Application");
  app.OlePropertySet("Visible",true);
  books = app.OlePropertyGet("Workbooks");
  books.OleProcedure("Add");
  book = books.OlePropertyGet("Item",1);
  sheet = book.OlePropertyGet("WorkSheets",1);
//Сформировали и записали вариантный массив из StringGrid
  String S;
  const int bounds[4] = {0, StringGrid1->RowCount, 0, StringGrid1->ColCount};
  Variant vData = VarArrayCreate(bounds, 3, varVariant);
  for(int i = 0; i < StringGrid1->RowCount; i++)
   for(int j = 0; j < StringGrid1->ColCount; j++)
    {
      if((StringGrid1->Cells[j][i]).IsEmpty()) S = "";
      else S = StringGrid1->Cells[j][i];
      vData.PutElement(S, i, j);
    }
  Rang = sheet.OlePropertyGet("Range",sheet.OlePropertyGet("Cells",1,1),
         sheet.OlePropertyGet("Cells",StringGrid1->RowCount,StringGrid1->ColCount));
  Rang.OlePropertySet("WrapText", false);
  Rang.OlePropertySet("Value",vData);
//Оформляем ширину столбцов
  for(int i = 0; i < StringGrid1->ColCount; i++)
   {
     Variant Clmn = sheet.OlePropertyGet("Cells", 1, i + 1).OlePropertyGet("EntireColumn");
     Clmn.OleFunction("AutoFit");
   }
}