Using a Multidimensional SAFEARRAY to pass data across from COM objects

The SAFEARRAY is a standard way to pass arrays or collections between COM objects.
Using COM’s standard marshaller , we can pass a collection of OLE Automation compatible
data types using SAFEARRAYs.
Multidimensional SAFARRAYs help us pass various automation compatible data types through the same array

Assume , we own an icecream parlor and would like to give our customers a list of
all the icecream flavors and their prices.
Now wouldn’t it be nice to package an array with both the flavor (represented by a
BSTR) and the price (represented as a float data type).
Notice that we have two diferent data types one a float and another a BSTR and yet
we package them neatly in a SAFEARRAY and send them across using COM’s standard marshaller.

Our data structure should look something like this:

flavor 1 flavor 2 flavor n
Flavors (0,0) (0,1) ………. (0,n)

price 1 price 2 price n
Prices (1,0) (1,0) ………. (1,n)

You can extend this whole analogy to actually pack every record in a database
table into an N-dimensional SAFEARRAY where N represents the number of fields
in the table.
While wading through some of the SAFEARRAY documentation , you may happen to come across
the term array descriptor.
An array descriptor is actually a pointer to an allocated SAFEARRAY structure.

Time now to have a look at our Icecream parlor example.

//////////////////////////////////////////////////////////////////////////////
//Function : GetFlavorsWithPrices (Example for Multidimensional SAFEARRAY)
//Parameters: VARIANT (out parameter that contains a SAFEARRAY of VARIANTs
// helping us to pass BSTR and float in the same array)
//Return Type : HRESULT
//////////////////////////////////////////////////////////////////////////////

STDMETHODIMP CIceCreamOrder::GetFlavorsWithPrices(VARIANT *pVariant)
{
// TODO: Add your implementation code here

//Initialize the bounds for the array
//Ours is a 2 dimensional array
SAFEARRAYBOUND safeBound[2];

//Set up the bounds for the first index
//That’s the number of flavors that we have
safeBound[0].cElements = m_vecIcecreamFlavors.size();
safeBound[0].lLbound = 0;

//Set up the bounds for the second index
safeBound[1].cElements = m_vecIcecreamPrices.size();
safeBound[1].lLbound = 0 ;

///Initialize the VARIANT
VariantInit(pVariant);
//The array type is VARIANT
//Storage will accomodate a BSTR and a float
pVariant->vt = VT_VARIANT | VT_ARRAY;
pVariant->parray = SafeArrayCreate(VT_VARIANT,2,safeBound);

//Initialize the vector iterators
std::vector::iterator iterFlavor;
std::vector<float>::iterator iterPrices;

//Used for indicating indexes in the Multidimensional array
long lDimension[2];
int iFlavorIndex = 0;

//Start iteration
iterPrices = m_vecIcecreamPrices.begin();
iterFlavor = m_vecIcecreamFlavors.begin();

//Iterate thru the list of flavors and prices
while(iterFlavor != m_vecIcecreamFlavors.end())
{

//Put the Element at (0,0), (0,1) , (0,2) ,………….(0,n)
lDimension[1] = iFlavorIndex;
lDimension[0] = 0;
CComVariant variantFlavor(SysAllocString((*iterFlavor).m_str));
SafeArrayPutElement(pVariant->parray,lDimension,&variantFlavor);

//Put the Element at (1,0), (1,1) , (1,2) ,………….(1,n)
lDimension[1] = iFlavorIndex;
lDimension[0] = 1;
CComVariant variantPrices(*iterPrices);
SafeArrayPutElement(pVariant->parray,lDimension,&variantPrices);

iFlavorIndex++;
iterPrices++;
iterFlavor++;

}

return S_OK;

}

Download demo project (Server) – 32 KB

Download demo project (Client) – 18 KB

More by Author

Must Read