Classe COleSafeArray

Classe per utilizzare matrici di tipo e dimensioni arbitrari.

Sintassi

class COleSafeArray : public tagVARIANT

Membri

Costruttori pubblici

Nome	Descrizione
COleSafeArray::COleSafeArray	Costruisce un oggetto COleSafeArray.

Metodi pubblici

Nome	Descrizione
COleSafeArray::AccessData	Recupera un puntatore ai dati della matrice.
COleSafeArray::AllocData	Alloca memoria per la matrice.
COleSafeArray::AllocDescriptor	Alloca memoria per il descrittore della matrice sicura.
COleSafeArray::Attach	Assegna il controllo della matrice esistente VARIANT all'oggetto COleSafeArray .
COleSafeArray::Clear	Libera tutti i dati nell'oggetto sottostante VARIANT.
COleSafeArray::Copy	Crea una copia di una matrice esistente.
COleSafeArray::Create	Crea una matrice sicura.
COleSafeArray::CreateOneDim	Crea un oggetto unidimensionale COleSafeArray .
COleSafeArray::D estroy	Elimina una matrice esistente.
COleSafeArray::D estroyData	Elimina i dati in una matrice sicura.
COleSafeArray::D estroyDescriptor	Elimina un descrittore di una matrice sicura.
COleSafeArray::D etach	Scollega la matrice VARIANT dall'oggetto COleSafeArray ( in modo che i dati non vengano liberati).
COleSafeArray::GetByteArray	Copia il contenuto della matrice sicura in un oggetto CByteArray.
COleSafeArray::GetDim	Restituisce il numero di dimensioni nella matrice.
COleSafeArray::GetElement	Recupera un singolo elemento della matrice sicura.
COleSafeArray::GetElemSize	Restituisce le dimensioni, in byte, di un elemento in una matrice sicura.
COleSafeArray::GetLBound	Restituisce il limite inferiore per qualsiasi dimensione di una matrice sicura.
COleSafeArray::GetOneDimSize	Restituisce il numero di elementi nell'oggetto unidimensionale COleSafeArray .
COleSafeArray::GetUBound	Restituisce il limite superiore per qualsiasi dimensione di una matrice sicura.
COleSafeArray::Lock	Incrementa il conteggio dei blocchi di una matrice e inserisce un puntatore ai dati della matrice nel descrittore di matrice.
COleSafeArray::P trOfIndex	Restituisce un puntatore all'elemento indicizzato.
COleSafeArray::P utElement	Assegna un singolo elemento nella matrice.
COleSafeArray::Redim	Modifica il limite meno significativo (più a destra) di una matrice sicura.
COleSafeArray::ResizeOneDim	Modifica il numero di elementi in un oggetto unidimensionale COleSafeArray .
COleSafeArray::UnaccessData	Decrementa il numero di blocchi di una matrice e invalida il puntatore recuperato da AccessData.
COleSafeArray::Unlock	Decrementa il numero di blocchi di una matrice in modo che possa essere liberato o ridimensionato.

Operatori pubblici

Nome	Descrizione
COleSafeArray::operator LPCVARIANT	Accede alla struttura sottostante VARIANT dell'oggetto COleSafeArray .
COleSafeArray::operator LPVARIANT	Accede alla struttura sottostante VARIANT dell'oggetto COleSafeArray .
COleSafeArray::operator =	Copia i valori in un COleSafeArray oggetto (SAFEARRAY, VARIANT, COleVarianto COleSafeArray matrice).
COleSafeArray::operator ==	Confronta due matrici varianti (SAFEARRAY, VARIANT, COleVarianto COleSafeArray matrici).
COleSafeArray::operator <<	Restituisce il contenuto di un COleSafeArray oggetto nel contesto di dump.

Osservazioni:

COleSafeArray deriva dalla struttura OLE VARIANT . Le funzioni membro OLE SAFEARRAY sono disponibili tramite COleSafeArray, nonché un set di funzioni membro appositamente progettate per matrici unidimensionali di byte.

Gerarchia di ereditarietà

tagVARIANT

COleSafeArray

Requisiti

Intestazione: afxdisp.h

COleSafeArray::AccessData

Recupera un puntatore ai dati della matrice.

void AccessData(void** ppvData);

Parametri

ppvData
Puntatore a un puntatore ai dati della matrice.

Osservazioni:

In caso di errore, la funzione genera un'eccezione CMemoryException o COleException.

Esempio

void CMainFrame::Sort(VARIANT* vArray)
{
   COleSafeArray sa;
   BSTR* pbstr;
   TCHAR buf[1024];
   LONG cElements, lLBound, lUBound;

   //needed for OLE2T macro below, include afxpriv.h
   USES_CONVERSION;

   // Type check VARIANT parameter. It should contain a BSTR array
   // passed by reference. The array must be passed by reference it is
   // an in-out-parameter.
   if (V_VT(vArray) != (VT_ARRAY | VT_BSTR))
   {
      AfxThrowOleDispatchException(1001,
         _T("Type Mismatch in Parameter. Pass a string array by reference"));
   }

   // clears data in sa and copies the variant data into sa
   sa.Attach(*vArray);

   // Check that array is 1 dimensional
   if (sa.GetDim() != 1)
   {
      AfxThrowOleDispatchException(1002,
         _T("Type Mismatch in Parameter. Pass a one-dimensional array"));
   }

   try
   {
      // Get array bounds.
      sa.GetLBound(1, &lLBound);
      sa.GetUBound(1, &lUBound);

      // Get a pointer to the elements of the array
      // and increments the lock count on the array
      sa.AccessData((LPVOID*)& pbstr);

      //get no. of elements in array
      cElements = lUBound - lLBound + 1;
      for (int i = 0; i < cElements; i++)
      {
         //output the elements of the array
         _stprintf_s(buf, 1024, _T("[%s]\n"), OLE2T(pbstr[i]));
         OutputDebugString(buf);
      }

      //decrement lock count
      sa.UnaccessData();
   }
   catch (COleException* pEx)
   {
      AfxThrowOleDispatchException(1003,
         _T("Unexpected Failure in FastSort method"));
      pEx->Delete();
   }
}

COleSafeArray::AllocData

Alloca memoria per una matrice sicura.

void AllocData();

Osservazioni:

In caso di errore, la funzione genera un'eccezione CMemoryException o COleException.

COleSafeArray::AllocDescriptor

Alloca memoria per il descrittore di una matrice sicura.

void AllocDescriptor(DWORD dwDims);

Parametri

dwDims
Numero di dimensioni nella matrice sicura.

Osservazioni:

In caso di errore, la funzione genera un'eccezione CMemoryException o COleException.

COleSafeArray::Attach

Fornisce il controllo dei dati in una matrice esistente VARIANT all'oggetto COleSafeArray .

void Attach(VARIANT& varSrc);

Parametri

varSrc
Oggetto VARIANT. Il parametro varSrc deve avere il VT_ARRAY VARTYPE.

Osservazioni:

Il tipo di origine VARIANTè impostato su VT_EMPTY. Questa funzione cancella i dati della matrice corrente, se presenti.

Esempio

Vedere l'esempio per COleSafeArray::AccessData.

COleSafeArray::Clear

Cancella la matrice sicura.

void Clear();

Osservazioni:

La funzione cancella una matrice sicura impostando l'oggetto VARTYPE su VT_EMPTY. Il contenuto corrente viene rilasciato e la matrice viene liberata.

COleSafeArray::COleSafeArray

Costruisce un oggetto COleSafeArray.

COleSafeArray();

COleSafeArray(
    const SAFEARRAY& saSrc,
    VARTYPE vtSrc);

COleSafeArray(
    LPCSAFEARRAY pSrc,
    VARTYPE vtSrc);

COleSafeArray(const COleSafeArray& saSrc);
COleSafeArray(const VARIANT& varSrc);
COleSafeArray(LPCVARIANT pSrc);
COleSafeArray(const COleVariant& varSrc);

Parametri

saSrc
Oggetto esistente COleSafeArray o SAFEARRAY da copiare nel nuovo COleSafeArray oggetto.

vtSrc
VARTYPE del nuovo COleSafeArray oggetto.

psaSrc
Puntatore a un SAFEARRAY oggetto da copiare nel nuovo COleSafeArray oggetto .

varSrc
Oggetto o COleVariant esistente VARIANT da copiare nel nuovo COleSafeArray oggetto.

pSrc
Puntatore a un VARIANT oggetto da copiare nel nuovo COleSafeArray oggetto.

Osservazioni:

Tutti questi costruttori creano nuovi COleSafeArray oggetti. Se non è presente alcun parametro, viene creato un oggetto vuoto COleSafeArray (VT_EMPTY). Se l'oggetto COleSafeArray viene copiato da un'altra matrice la cui proprietà VARTYPE è nota in modo implicito (un COleSafeArrayoggetto , COleVarianto VARIANT), il valore VARTYPE della matrice di origine viene mantenuto e non deve essere specificato. Se viene COleSafeArray copiato da un'altra matrice la cui proprietà VARTYPE non è nota (SAFEARRAY), il parametro VARTYPE deve essere specificato nel parametro vtSrc .

In caso di errore, la funzione genera un'eccezione CMemoryException o COleException.

COleSafeArray::Copy

Crea una copia di una matrice sicura esistente.

void Copy(LPSAFEARRAY* ppsa);

Parametri

ppsa
Puntatore a una posizione in cui restituire il nuovo descrittore di matrice.

Osservazioni:

In caso di errore, la funzione genera un'eccezione CMemoryException o COleException.

COleSafeArray::Create

Alloca e inizializza i dati per la matrice.

void Create(
    VARTYPE vtSrc,
    DWORD dwDims,
    DWORD* rgElements);

void Create(
    VARTYPE vtSrc,
    DWORD dwDims,
    SAFEARRAYBOUND* rgsabounds);

Parametri

vtSrc
Tipo di base della matrice, ovvero VARTYPE di ogni elemento della matrice. VARTYPE è limitato a un subset dei tipi varianti. Non è possibile impostare né la VT_ARRAY né il flag VT_BYREF. VT_EMPTY e VT_NULL non sono tipi di base validi per la matrice. Tutti gli altri tipi sono legali.

dwDims
Numero di dimensioni nella matrice. Questa operazione può essere modificata dopo la creazione della matrice con Redim.

rgElements
Puntatore a una matrice del numero di elementi per ogni dimensione nella matrice.

rgsabounds
Puntatore a un vettore di limiti (uno per ogni dimensione) da allocare per la matrice.

Osservazioni:

Questa funzione cancella i dati della matrice corrente, se necessario. In caso di errore, la funzione genera un'eccezione CMemoryException.

Esempio

COleSafeArray saMatrix;
DWORD numElements[] = { 10, 5 };

// creates a 2 dimensional safearray of type VT_I2 
// with size 10x5 elements, with all indices starting at 0(default)
saMatrix.Create(VT_I2, 2, numElements);

ASSERT(saMatrix.GetDim() == 2);

COleSafeArray saVector;
SAFEARRAYBOUND rgsabounds[] = { {5, 2} };

// creates a 1 dimensional safearray of type VT_I1 
// with size 5 elements, with the index starting at 2
saVector.Create(VT_I1, 1, rgsabounds);

ASSERT(saVector.GetDim() == 1);

COleSafeArray::CreateOneDim

Crea un nuovo oggetto unidimensionale COleSafeArray .

void CreateOneDim(
    VARTYPE vtSrc,
    DWORD dwElements,
    const void* pvSrcData = NULL,
    long nLBound = 0);

Parametri

vtSrc
Tipo di base della matrice, ovvero VARTYPE di ogni elemento della matrice.

dwElements
Numero di elementi nella matrice. Questa operazione può essere modificata dopo la creazione della matrice con ResizeOneDim.

pvSrcData
Puntatore ai dati da copiare nella matrice.

nLBound
Limite inferiore della matrice.

Osservazioni:

La funzione alloca e inizializza i dati per la matrice, copiando i dati specificati se il puntatore pvSrcData non è NULL.

In caso di errore, la funzione genera un'eccezione CMemoryException.

Esempio

VARIANT varColInfo[3];

//initialize VARIANTs
for (int i = 0; i < 3; i++)
   VariantInit(&varColInfo[i]);

// Column Name
varColInfo[0].vt = VT_BSTR;
varColInfo[0].bstrVal = ::SysAllocString(L"Name");

// Column Type
varColInfo[1].vt = VT_UI4;
varColInfo[1].lVal = 1;

COleSafeArray sa;
//create a 1 dimensional safearray of VARIANTs
//& initialize it with varColInfo VARIANT array
sa.CreateOneDim(VT_VARIANT, 2, varColInfo);

//check that the dimension is 2
ASSERT(sa.GetOneDimSize() == 2);

//increase safearray size by 1
sa.ResizeOneDim(3);

// populate the last element of the safearray, (Column Size)
varColInfo[2].vt = VT_I4;
varColInfo[2].lVal = 30;
long el = 2;
sa.PutElement(&el, &varColInfo[2]);

COleSafeArray::D estroy

Elimina definitivamente un descrittore di matrice esistente e tutti i dati nella matrice.

void Destroy();

Osservazioni:

Se gli oggetti vengono archiviati nella matrice, ogni oggetto viene rilasciato. In caso di errore, la funzione genera un'eccezione CMemoryException o COleException.

COleSafeArray::D estroyData

Elimina tutti i dati in una matrice sicura.

void DestroyData();

Osservazioni:

Se gli oggetti vengono archiviati nella matrice, ogni oggetto viene rilasciato. In caso di errore, la funzione genera un'eccezione CMemoryException o COleException.

COleSafeArray::D estroyDescriptor

Elimina un descrittore di una matrice sicura.

void DestroyDescriptor();

Osservazioni:

In caso di errore, la funzione genera un'eccezione CMemoryException o COleException.

COleSafeArray::D etach

Scollega i VARIANT dati dall'oggetto COleSafeArray .

VARIANT Detach();

Valore restituito

Valore sottostante VARIANT nell'oggetto COleSafeArray .

Osservazioni:

La funzione scollega i dati in una matrice sicura impostando varTYPE dell'oggetto su VT_EMPTY. È responsabilità del chiamante liberare la matrice chiamando la funzione Windows VariantClear.

In caso di errore, la funzione genera un'eccezione COleException.

Esempio

Vedere l'esempio per COleSafeArray::P utElement.

COleSafeArray::GetByteArray

Copia il contenuto della matrice sicura in un oggetto CByteArray.

void GetByteArray(CByteArray& bytes);

Parametri

bytes
Riferimento a un oggetto CByteArray .

COleSafeArray::GetDim

Restituisce il numero di dimensioni nell'oggetto COleSafeArray .

DWORD GetDim();

Valore restituito

Numero di dimensioni nella matrice sicura.

Esempio

COleSafeArray saMatrix;
DWORD numElements[] = { 10, 5 };

// creates a 2 dimensional safearray of type VT_I2 
// with size 10x5 elements, with all indices starting at 0(default)
saMatrix.Create(VT_I2, 2, numElements);

ASSERT(saMatrix.GetDim() == 2);

COleSafeArray saVector;
SAFEARRAYBOUND rgsabounds[] = { {5, 2} };

// creates a 1 dimensional safearray of type VT_I1 
// with size 5 elements, with the index starting at 2
saVector.Create(VT_I1, 1, rgsabounds);

ASSERT(saVector.GetDim() == 1);

COleSafeArray::GetElement

Recupera un singolo elemento della matrice sicura.

void GetElement(
    long* rgIndices,
    void* pvData);

Parametri

rgIndices
Puntatore a una matrice di indici per ogni dimensione della matrice.

pvData
Puntatore alla posizione in cui posizionare l'elemento della matrice.

Osservazioni:

Questa funzione chiama automaticamente le funzioni SafeArrayLock di Windows e prima e SafeArrayUnlock dopo il recupero dell'elemento. Se l'elemento dati è una stringa, un oggetto o una variante, la funzione copia l'elemento nel modo corretto. Il parametro pvData deve puntare a un buffer sufficientemente grande da contenere l'elemento.

In caso di errore, la funzione genera un'eccezione CMemoryException o COleException.

Esempio

//sa is of type COleSafeArray with 2 dimensions

//Determine upper bounds for both dimensions
long lNumRows;
long lNumCols;
sa.GetUBound(1, &lNumRows);
sa.GetUBound(2, &lNumCols);

//Display the elements in the SAFEARRAY.
long index[2];
VARIANT val;

//Determine lower bounds for both dimensions
long lowRow, lowCol;
sa.GetLBound(1, &lowRow);
sa.GetLBound(2, &lowCol);

for (long r = lowRow; r <= lNumRows; r++)
{
   for (long c = lowCol; c <= lNumCols; c++)
   {
      index[0] = r;
      index[1] = c;

      //retrieve each element of the safearray
      sa.GetElement(index, &val);

      switch (val.vt)
      {
      case VT_R8:
         TRACE(_T("%1.2f\n"), val.dblVal);
         break;

      case VT_BSTR:
         TRACE(_T("%s\n"), (CString)val.bstrVal);
         break;

         // other cases omitted

      case VT_EMPTY:
         TRACE(_T("<empty>\n"));
         break;
      }
   }
}

COleSafeArray::GetElemSize

Recupera le dimensioni di un elemento in un COleSafeArray oggetto .

DWORD GetElemSize();

Valore restituito

Dimensioni, in byte, degli elementi di una matrice sicura.

COleSafeArray::GetLBound

Restituisce il limite inferiore per qualsiasi dimensione di un COleSafeArray oggetto .

void GetLBound(
    DWORD dwDim,
    long* pLBound);

Parametri

dwDim
Dimensione della matrice per la quale ottenere il limite inferiore.

pLBound
Puntatore alla posizione in cui restituire il limite inferiore.

Osservazioni:

In caso di errore, la funzione genera un'eccezione COleException.

Esempio

COleSafeArray saMatrix;
DWORD numElements[] = { 10, 5 };

// creates a 2 dimensional safearray of type VT_I2 
// with size 10x5 elements, with all indices starting at 0(default)
saMatrix.Create(VT_I2, 2, numElements);

long lLBound;

//get lower bound for 1st dimension
saMatrix.GetLBound(1, &lLBound);

ASSERT(lLBound == 0);

//get lower for 2nd dimension
saMatrix.GetLBound(2, &lLBound);

ASSERT(lLBound == 0);

COleSafeArray saVector;
SAFEARRAYBOUND rgsabounds[] = { {5, 1} };

// creates a 1 dimensional safearray of type VT_I1 
// with size 5 elements, with the index starting at 1
saVector.Create(VT_I1, 1, rgsabounds);

//get lower bound for 1st dimension
saVector.GetLBound(1, &lLBound);

ASSERT(lLBound == 1);

COleSafeArray::GetOneDimSize

Restituisce il numero di elementi nell'oggetto unidimensionale COleSafeArray .

DWORD GetOneDimSize();

Valore restituito

Numero di elementi nella matrice sicura unidimensionale.

Esempio

Vedere l'esempio per COleSafeArray::CreateOneDim.

COleSafeArray::GetUBound

Restituisce il limite superiore per qualsiasi dimensione di una matrice sicura.

void GetUBound(
    DWORD dwDim,
    long* pUBound);

Parametri

dwDim
Dimensione della matrice per la quale ottenere il limite superiore.

pUBound
Puntatore alla posizione in cui restituire il limite superiore.

Osservazioni:

In caso di errore, la funzione genera un'eccezione COleException.

Esempio

COleSafeArray saMatrix;
DWORD numElements[] = { 10, 5 };

// creates a 2 dimensional safearray of type VT_I2 
// with size 10x5 elements, with all indices starting at 0(default)
saMatrix.Create(VT_I2, 2, numElements);

long lUBound;
ASSERT(saMatrix.GetDim() == 2);

//get upper bound for 1st dimension
saMatrix.GetUBound(1, &lUBound);

ASSERT(lUBound == 9);

//get upper bound for 2nd dimension
saMatrix.GetUBound(2, &lUBound);

ASSERT(lUBound == 4);

COleSafeArray saVector;
SAFEARRAYBOUND rgsabounds[] = { {5, 1} };

// creates a 1 dimensional safearray of type VT_I1 
// with size 5 elements, with the index starting at 1
saVector.Create(VT_I1, 1, rgsabounds);

//get upper bound for 1st dimension
saVector.GetUBound(1, &lUBound);

ASSERT(lUBound == 5);

COleSafeArray::Lock

Incrementa il numero di blocchi di una matrice e inserisce un puntatore ai dati della matrice nel descrittore di matrice.

void Lock();

Osservazioni:

In caso di errore, genera un'eccezione COleException.

Il puntatore nel descrittore di matrice è valido fino a quando Unlock non viene chiamato. Le chiamate a Lock possono essere annidate. È necessario un numero uguale di chiamate a Unlock .

Non è possibile eliminare una matrice mentre è bloccata.

COleSafeArray::operator LPCVARIANT

Chiamare questo operatore di cast per accedere alla struttura sottostante VARIANT per questo COleSafeArray oggetto.

operator LPCVARIANT() const;

COleSafeArray::operator LPVARIANT

Chiamare questo operatore di cast per accedere alla struttura sottostante VARIANT per questo COleSafeArray oggetto.

operator LPVARIANT();

Osservazioni:

Si noti che la modifica del valore nella VARIANT struttura a cui si accede dal puntatore restituito da questa funzione modificherà il valore di questo COleSafeArray oggetto.

COleSafeArray::operator =

Questi operatori di assegnazione di overload copiano il valore di origine in questo COleSafeArray oggetto.

COleSafeArray& operator=(const COleSafeArray& saSrc);
COleSafeArray& operator=(const VARIANT& varSrc);
COleSafeArray& operator=(LPCVARIANT pSrc);
COleSafeArray& operator=(const COleVariant& varSrc);

Osservazioni:

Di seguito è riportata una breve descrizione di ogni operatore:

• operator =( saSrc ) Copia un oggetto esistente COleSafeArray in questo oggetto.

• operator =( varSrc ) Copia in questo oggetto una matrice o COleVariant esistenteVARIANT.

• operator =( pSrc ) Copia l'oggetto VARIANT matrice accessibile da pSrc in questo oggetto.

COleSafeArray::operator ==

Questo operatore confronta due matrici (SAFEARRAY, VARIANT, COleVarianto COleSafeArray matrici) e restituisce un valore diverso da zero se sono uguali; in caso contrario, 0.

BOOL operator==(const SAFEARRAY& saSrc) const;  BOOL operator==(LPCSAFEARRAY pSrc) const;

BOOL operator==(const COleSafeArray& saSrc) const;  BOOL operator==(const VARIANT& varSrc) const;

BOOL operator==(LPCVARIANT pSrc) const;  BOOL operator==(const COleVariant& varSrc) const;

Osservazioni:

Due matrici sono uguali se hanno un numero uguale di dimensioni, dimensioni uguali in ogni dimensione e valori di elemento uguali.

COleSafeArray::operator <<

L'operatore COleSafeArray di inserimento (<<) supporta il dump diagnostico e l'archiviazione di un COleSafeArray oggetto in un archivio.

CDumpContext& AFXAPI operator<<(
    CDumpContext& dc,
    COleSafeArray& saSrc);

COleSafeArray::P trOfIndex

Restituisce un puntatore all'elemento specificato dai valori di indice.

void PtrOfIndex(
    long* rgIndices,
    void** ppvData);

Parametri

rgIndices
Matrice di valori di indice che identificano un elemento della matrice. È necessario specificare tutti gli indici per l'elemento .

ppvData
In caso di restituzione, puntatore all'elemento identificato dai valori in rgIndices.

COleSafeArray::P utElement

Assegna un singolo elemento nella matrice.

void PutElement(
    long* rgIndices,
    void* pvData);

Parametri

rgIndices
Puntatore a una matrice di indici per ogni dimensione della matrice.

pvData
Puntatore ai dati da assegnare alla matrice. VT_DISPATCH, VT_UNKNOWN e VT_BSTR tipi varianti sono puntatori e non richiedono un altro livello di riferimento indiretto.

Osservazioni:

Questa funzione chiama automaticamente le funzioni Di Windows SafeArrayLock e SafeArrayUnlock prima e dopo l'assegnazione dell'elemento. Se l'elemento dati è una stringa, un oggetto o una variante, la funzione lo copia correttamente e se l'elemento esistente è una stringa, un oggetto o una variante, esso viene cancellato correttamente.

Si noti che possono esistere più blocchi in una matrice. È pertanto possibile inserire elementi in una matrice mentre questa è bloccata da altre operazioni.

In caso di errore, la funzione genera un'eccezione CMemoryException o COleException.

Esempio

VARIANT retVariantArray()
{
   COleSafeArray saRet;
   DWORD numElements[] = { 10, 10 }; // 10x10

   // Create the 2 dimensional safe-array of type VT_R8 with size 10x10
   saRet.Create(VT_R8, 2, numElements);

   // Initialize safearray  with values...
   long index[2];
   for (index[0] = 0; index[0] < 10; index[0]++)
   {
      for (index[1] = 0; index[1] < 10; index[1]++)
      {
         double val = index[0] + index[1] * 10;
         //populate the safearray elements with double values
         saRet.PutElement(index, &val);
      }
   }
   // Return the safe-array encapsulated in a VARIANT...
   return saRet.Detach();
}

COleSafeArray::Redim

Modifica il limite meno significativo (più a destra) di una matrice sicura.

void Redim(SAFEARRAYBOUND* psaboundNew);

Parametri

psaboundNew
Puntatore a una nuova struttura associata a matrice sicura contenente il nuovo limite di matrice. È possibile modificare solo la dimensione meno significativa di una matrice.

Osservazioni:

In caso di errore, la funzione genera un'eccezione COleException.

COleSafeArray::ResizeOneDim

Modifica il numero di elementi in un oggetto unidimensionale COleSafeArray .

void ResizeOneDim(DWORD dwElements);

Parametri

dwElements
Numero di elementi nella matrice sicura unidimensionale.

Osservazioni:

In caso di errore, la funzione genera un'eccezione COleException.

Esempio

Vedere l'esempio per COleSafeArray::CreateOneDim.

COleSafeArray::UnaccessData

Decrementa il numero di blocchi di una matrice e invalida il puntatore recuperato da AccessData.

void UnaccessData();

Osservazioni:

In caso di errore, la funzione genera un'eccezione COleException.

Esempio

Vedere l'esempio per COleSafeArray::AccessData.

COleSafeArray::Unlock

Decrementa il numero di blocchi di una matrice in modo che possa essere liberato o ridimensionato.

void Unlock();

Osservazioni:

Questa funzione viene chiamata al termine dell'accesso ai dati in una matrice. In caso di errore, genera un'eccezione COleException.

Vedi anche

Grafico della gerarchia
Classe COleVariant
Classe CRecordset
Classe CDatabase