xlAutoFree/xlAutoFree12 (traduction automatique)
Dernière modification : mercredi 18 mars 2009
S’applique à : Excel 2010 | Office 2010 | VBA | Visual Studio
Important
Cet article a été traduit automatiquement, voir l’avertissement. Vous pouvez consulter la version en anglais de cet article ici.
Appelée par Microsoft Excel juste après qu’une fonction de feuille de calcul XLL lui retourne un XLOPER/XLOPER12 avec un indicateur lui signalant qu’il y a encore de la mémoire que la XLL doit libérer. Cela permet à la XLL de retourner à la feuille de calcul des références externes, des chaînes et des tableaux dynamiquement alloués sans fuites de mémoire. Pour plus d’informations, voir Gestion de la mémoire dans Excel (traduction automatique).
Démarrage de la xlAutoFree12 en Excel 2007 fonction et le type de données XLOPER12 sont pris en charge.
Excel ne nécessite pas un XLL mettre en œuvre et d'exportation de ces fonctions. Toutefois, vous devez le faire si vos fonctions XLL renvoient un XLOPER ou XLOPER12 qui a été allouée dynamiquement ou qui contient des pointeurs vers la mémoire allouée dynamiquement. Assurez-vous que votre choix de la gestion de mémoire pour ces types est cohérente tout au long de votre XLL et avec le mode d'implémentation de xlAutoFree et xlAutoFree12.
À l'intérieur de la fonction xlAutoFree/xlAutoFree12, rappels dans Excel sont désactivées, à une exception près : xlFree peut être appelé pour libérer de la mémoire allouée par Excel.
void WINAPI xlAutoFree(LPXLOPER pxFree);
void WINAPI xlAutoFree12(LPXLOPER12 pxFree);
Paramètres
pxFree (LPXLOPER in the case of xlAutoFree)
pxFree (LPXLOPER12 in the case of xlAutoFree12)
Un pointeur vers le XLOPER ou le XLOPER12 a mémoire doit être libérées.
Valeur de propriété/Valeur renvoyée
Cette fonction ne retourne pas de valeur et doit être déclarée comme retournant void.
Notes
Avertissement traduction automatique : cet article a été traduit par un ordinateur, sans intervention humaine. Microsoft propose cette traduction automatique pour offrir aux personnes ne maîtrisant pas l’anglais l’accès au contenu relatif aux produits, services et technologies Microsoft. Comme cet article a été traduit automatiquement, il risque de contenir des erreurs de grammaire, de syntaxe ou de terminologie.
Remarques
Lorsque Excel est configuré pour utiliser le recalcul de classeurs multithread, xlAutoFree/xlAutoFree12 est appelée sur le même thread que celui utilisé pour appeler la fonction qui l'a renvoyée. L'appel à xlAutoFree/xlAutoFree12 est toujours effectué avant que les cellules de feuille de calcul suivantes sont évaluées sur ce thread. Cela simplifie la conception du thread-safe dans votre XLL.
Si la fonction xlAutoFree/xlAutoFree12 que vous fournir examine le champ xltype de pxFree, n'oubliez pas que le bit xlbitDLLFree est toujours défini.
Exemple
Exemple d'implémentation 1
Le premier code à partir de \SAMPLES\EXAMPLE\EXAMPLE.C illustre une implémentation très spécifique de xlAutoFree, qui est conçu pour fonctionner avec une fonction, fArray. En règle générale, votre XLL ont plusieurs fonction retourner la mémoire doit être libérée, auquel cas une implémentation moins élevée est requise.
Exemple d'implémentation 2
Le deuxième exemple d'implémentation est cohérente avec les hypothèses utilisées dans les exemples de création de XLOPER12 dans la section 1.6.3, xl12_Str_example, xl12_Ref_example et xl12_Multi_example. Les hypothèses sont qui, lorsque le bit xlbitDLLFree a été ensemble, tous les cordes, tableau, et mémoire de référence externe a été allouée dynamiquement à l'aide de malloc et doit donc être libéré dans un appel à libérer.
Exemple d'implémentation 3
Le troisième exemple d'implémentation est cohérent avec un XLL où des fonctions exportées renvoient XLOPER12s allouent des chaînes, des références externes et des tableaux à l'aide de malloc, et où le XLOPER12 lui-même est allouée également dynamiquement. Renvoyant un pointeur vers un XLOPER12 alloué dynamiquement est un moyen de s'assurer que la fonction est thread-safe.
//////////////////////////////////////////
// BEGIN EXAMPLE IMPLEMENTATION 1
//////////////////////////////////////////
LPXLOPER12 WINAPI fArray(void)
{
LPXLOPER12 pxArray;
static XLOPER12 xMulti;
int i;
int rwcol;
xMulti.xltype = xltypeMulti | xlbitDLLFree;
xMulti.val.array.columns = 1;
xMulti.val.array.rows = 8;
// For large values of rows and columns, this would overflow
// use __int64 in that case and return an error if rwcol
// contains a number that won't fit in sizeof(int) bytes
rwcol = xMulti.val.array.columns * xMulti.val.array.rows;
pxArray = (LPXLOPER12)GlobalLock(hArray = GlobalAlloc(GMEM_ZEROINIT, rwcol * sizeof(XLOPER12)));
xMulti.val.array.lparray = pxArray;
for(i = 0; i < rwcol; i++)
{
pxArray[i].xltype = xltypeInt;
pxArray[i].val.w = i;
}
// Word of caution - returning static XLOPERs/XLOPER12s is not thread safe
// for UDFs declared as thread safe, use alternate memory allocation mechanisms
return (LPXLOPER12)&xMulti;
}
void WINAPI xlAutoFree12(LPXLOPER12 pxFree)
{
GlobalUnlock(hArray);
GlobalFree(hArray);
return;
}
//////////////////////////////////////////
// BEGIN EXAMPLE IMPLEMENTATION 2
//////////////////////////////////////////
void WINAPI xlAutoFree12(LPXLOPER12 pxFree)
{
if(pxFree->xltype & xltypeMulti)
{
/* Assume all string elements were allocated using malloc, and
** need to be freed using free. Then free the array itself.
*/
int size = pxFree->val.array.rows *
pxFree->val.array.columns;
LPXLOPER12 p = pxFree->val.array.lparray;
for(; size-- > 0; p++) // check elements for strings
if(p->xltype == xltypeStr)
free(p->val.str);
free(pxFree->val.array.lparray);
}
else if(pxFree->xltype & xltypeStr)
{
free(pxFree->val.str);
}
else if(pxFree->xltype & xltypeRef)
{
free(pxFree->val.mref.lpmref);
}
}
//////////////////////////////////////////
// BEGIN EXAMPLE IMPLEMENTATION 3
//////////////////////////////////////////
LPXLOPER12 WINAPI example_xll_function(LPXLOPER12 pxArg)
{
// Thread-safe return value. Every invocation of this function
// gets its own piece of memory.
LPXLOPER12 pxRtnValue = (LPXLOPER12)malloc(sizeof(XLOPER12));
// Initialize to a safe default
pxRtnValue->xltype = xltypeNil;
// Set the value of pxRtnValue making sure that strings, external
// references, arrays, and strings within arrays are all dynamically
// allocated using malloc.
// (code omitted)
// ...
// Set xlbitDLLFree regardless of the type of the return value to
// ensure xlAutoFree12 is called and pxRtnValue is freed.
pxRtnValue->xltype |= xlbitDLLFree;
return pxRtnValue;
}
void WINAPI xlAutoFree12(LPXLOPER pxFree)
{
if(pxFree->xltype & xltypeMulti)
{
// Assume all string elements were allocated using malloc, and
// need to be freed using free. Then free the array itself.
int size = pxFree->val.array.rows *
pxFree->val.array.columns;
LPXLOPER12 p = pxFree->val.array.lparray;
for(; size-- > 0; p++) // check elements for strings
if(p->xltype == xltypeStr)
free(p->val.str);
free(pxFree->val.array.lparray);
}
else if(pxFree->xltype & xltypeStr)
{
free(pxFree->val.str);
}
else if(pxFree->xltype & xltypeRef)
{
free(pxFree->val.mref.lpmref);
}
// Assume pxFree was itself dynamically allocated using malloc.
free(pxFree);
}
Voir aussi
Concepts
Gestionnaire de compléments et fonctions d’interface XLL (traduction automatique)