Convert integer to Excel range

Dim rng As Range
Dim iRowCount As Integer, iColCount As Integer

Set rng = ThisWorkbook.Worksheets(1).Range("A1:C15")
'get columns count
iColCount = rng.Cells.Columns.Count
'get rows count
iRowCount = rng.Cells.Rows.Count

'display message
MsgBox "Columns count: " & iColCount & vbCr & "Rows count: " & iRowCount, vbInformation, rng.Address

Set rng = Nothing

1. I've added variables rows and cols - these control the size of the range affected in excel.
2. I had to add some GUID definitions to the file since not using MS compiler
3. You need to link the ole32 and oleaut32 libraries - .lib for VS, .a for gcc
4. nv3 was spot-on saying that you can simply use the buffer for SysAllocString
5. I've included the entire source in the interests of completeness

#define UNICODE
#include <windows.h>
#include <stdio.h>
#include <ole2.h> // OLE2 Definitions


const GUID GUID_NULL = { 0, 0, 0, { 0, 0, 0, 0, 0, 0, 0, 0 } };
const GUID IID_IUnknown = {0x00000000, 0x0000, 0x0000, {0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46}};
const GUID IID_IDispatch = {0x00020400, 0x0000, 0x0000, {0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x46}};

int cols=8, rows=16;

// 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, L"NULL IDispatch passed to AutoWrap()", L"Error", 0x10010);
        _exit(0);
    }

    // Variables used...
    DISPPARAMS dp = { NULL, NULL, 0, 0 };
    DISPID dispidNamed = DISPID_PROPERTYPUT;
    DISPID dispID;
    HRESULT hr;
    wchar_t 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)) {
        wsprintf(buf, L"IDispatch::GetIDsOfNames(\"%s\") failed w/err 0x%08lx", szName, hr);
        MessageBox(NULL, buf, L"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)) {
        wsprintf(buf, L"IDispatch::Invoke(\"%s\"=%08lx) failed w/err 0x%08lx", szName, dispID, hr);
        MessageBox(NULL, buf, L"AutoWrap()", 0x10010);
        _exit(0);
        return hr;
    }
    // End variable-argument section...
    va_end(marker);

    delete [] pArgs;

    return hr;
}

int main()
{
// Initialize COM for this thread...
   CoInitialize(NULL);

   // Get CLSID for our server...
   CLSID clsid;
   HRESULT hr = CLSIDFromProgID(L"Excel.Application", &clsid);

   if(FAILED(hr)) {

      MessageBox(NULL, L"CLSIDFromProgID() failed", L"Error", 0x10010);
      return -1;
   }

   // Start server and get IDispatch...
   IDispatch *pXlApp;
   hr = CoCreateInstance(clsid, NULL, CLSCTX_LOCAL_SERVER, IID_IDispatch, (void **)&pXlApp);
   if(FAILED(hr)) {
      MessageBox(NULL, L"Excel not registered properly", L"Error", 0x10010);
      return -2;
   }

   // 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
   IDispatch *pXlBooks;
   {
      VARIANT result;
      VariantInit(&result);
      AutoWrap(DISPATCH_PROPERTYGET, &result, pXlApp, L"Workbooks", 0);
      pXlBooks = result.pdispVal;
   }

   // Call Workbooks.Add() to get a new workbook...
   IDispatch *pXlBook;
   {
      VARIANT result;
      VariantInit(&result);
      AutoWrap(DISPATCH_PROPERTYGET, &result, pXlBooks, L"Add", 0);
      pXlBook = result.pdispVal;
   }

   // Create a 15x15 safearray of variants...
   VARIANT arr;
   arr.vt = VT_ARRAY | VT_VARIANT;
   {
      SAFEARRAYBOUND sab[2];
      sab[0].lLbound = 1; sab[0].cElements = rows;
      sab[1].lLbound = 1; sab[1].cElements = cols;
      arr.parray = SafeArrayCreate(VT_VARIANT, 2, sab);
   }

   // Fill safearray with some values...
   for(int i=1; i<=rows; i++)
   {
      for(int j=1; j<=cols; j++)
      {
         // Create entry value for (i,j)
         VARIANT tmp;
         tmp.vt = VT_I4;
         tmp.lVal = i*j;
         // Add to safearray...
         long indices[] = {i,j};
         SafeArrayPutElement(arr.parray, indices, (void *)&tmp);
      }
   }

   // Get ActiveSheet object
   IDispatch *pXlSheet;
   {
      VARIANT result;
      VariantInit(&result);
      AutoWrap(DISPATCH_PROPERTYGET, &result, pXlApp, L"ActiveSheet", 0);
      pXlSheet = result.pdispVal;
   }

   // Get Range object for the Range A1:O15...
   IDispatch *pXlRange;
   {
      VARIANT parm;
      parm.vt = VT_BSTR;
      wchar_t buffer[32];
      wsprintf(buffer, L"%c%d:%c%d", 'A'+0, 1, 'A'+cols-1, rows);
      parm.bstrVal = SysAllocString(buffer);
      //parm.bstrVal = SysAllocString(L"A1:O15");

      VARIANT result;
      VariantInit(&result);
      AutoWrap(DISPATCH_PROPERTYGET, &result, pXlSheet, L"Range", 1, parm);
      VariantClear(&parm);

      pXlRange = result.pdispVal;
   }

   // Set range with our safearray...
   AutoWrap(DISPATCH_PROPERTYPUT, NULL, pXlRange, L"Value", 1, arr);

   // Wait for user...
   MessageBox(NULL, L"All done.", L"Notice", 0x10000);

   // Set .Saved property of workbook to TRUE so we aren't prompted
   // to save when we tell Excel to quit...
   {
      VARIANT x;
      x.vt = VT_I4;
      x.lVal = 1;
      AutoWrap(DISPATCH_PROPERTYPUT, NULL, pXlBook, L"Saved", 1, x);
   }

   // Tell Excel to quit (i.e. App.Quit)
   AutoWrap(DISPATCH_METHOD, NULL, pXlApp, L"Quit", 0);

   // Release references...
   pXlRange->Release();
   pXlSheet->Release();
   pXlBook->Release();
   pXlBooks->Release();
   pXlApp->Release();
   VariantClear(&arr);


   // Uninitialize COM for this thread...
   CoUninitialize();


    return 0;
}

#define UNICODE 
#include <stdio.h>
#include <stdlib.h>
#include <string.h> 
#include <string> 
#include <windows.h> 
using namespace std; 
wstring toBase26(int number) 
{
	number = abs(number);
	wstring converted = L""; 
	int iteration = 0; // the variable that makes the difference!

	// Repeatedly divide the number by 26 and convert the 
	// remainder into the appropriate letter.
	do
	{ 
		int remainder = number % 26;
		if( iteration && number<25) // this line was missing!
			remainder--;
		converted = (wchar_t)(remainder + 'A') + converted;
		number = (number - remainder) / 26; 

		iteration = 1; // and this one!
	} 
	while (number > 0); 
	return converted; 
} 

wstring makeRangeStr(int firstCol, int lastCol, int firstRow, int lastRow)
{ 
	wstring result, tmp;
	wchar_t buffer[16];
	result = toBase26(firstCol-1);
	wsprintf(buffer, L"%d", firstRow);
	result += buffer;
	result += L":"; 
	result += toBase26(lastCol-1); 
	wsprintf(buffer, L"%d", lastRow); 
	result += buffer; 
	return result; 
} 

int main() 
{ 
	int cols=29, rows=18; 
	wstring tmp = makeRangeStr(1,cols,1,rows); 
	wprintf(L"%s\n", tmp.c_str());
	return 0; 
}

wchar_t colName[3];

     if (cntCols <= 26)
	 swprintf_s (colName, L"%c", 'A' + cntCols - 1);
     else 
          if (cntCols <= 26*26)
	     swprintf_s (colName, L"%c%c", 'A' + cntCols /26 - 1, 'A' + cntCols %26 - 1);
	  else
	      // ... error processing	


wchar_t buffer[256]; 

swprintf_s (buffer, L"A1:%s%d", colName, cntRows+1); // +1 because in first row will be names of columns!

VARIANT parm;
parm.vt = VT_BSTR;
parm.bstrVal = ::SysAllocString(buffer);

int i=26,cntLettersInString=1;

while(cntCols - i)  
{
   cntLettersInString++;
   
   i* = 26;
}

if( cntCols %(i/26)>26)
    'A' + cntCols %(i/26) -26 -1; // -26 since it is greater than 'Z'
    'A' + cntCols %(i/26) - 1;

'A' + cntCols /(i/26) -1;