Classes basées sur un modèle
Cet article explique les classes de collection basées sur un modèle de type sécurisé dans MFC 3.0 et les versions ultérieures. L'utilisation de ces modèles pour créer des collections de type sécurisé est une solution plus pratique qui offre une plus grande cohérence des types que les classes de collection qui ne sont pas basées sur des modèles.
MFC prédéfinit deux catégories de collections basées sur des modèles :
Classes de tableau, de liste et de mappage simples
CArray,CList,CMapTableaux, listes et mappages de pointeurs typés
CTypedPtrArray,CTypedPtrList,CTypedPtrMap
Toutes les classes de collection simples sont dérivées de la classe CObject, de sorte qu'elles héritent de la sérialisation, de la création dynamique et d'autres propriétés de CObject. Les classes de collection de pointeurs typés nécessitent que vous spécifiez la classe de dérivation, qui doit être l’une des collections de pointeurs non basées sur un modèle prédéfinies par MFC, par exemple CPtrList ou CPtrArray. La nouvelle classe de collection hérite de la classe de base spécifiée, et ses fonctions membres utilisent des appels encapsulés aux membres de la classe de base pour appliquer la cohérence des types.
Pour plus d’informations sur les modèles C++, consultez Modèles dans la référence du langage C++.
Utilisation de modèles de tableau, de liste et de mappage simples
Pour utiliser les modèles de collection simples, vous devez connaître le type de données pouvant être stockées dans ces collections et les paramètres à utiliser dans les déclarations de collection.
Utilisation simple du tableau et de la liste
Les classes de tableau et de liste simples, CArray et CList, prennent deux paramètres : TYPE et ARG_TYPE. Ces classes peuvent stocker n’importe quel type de données, que vous spécifiez dans le paramètre TYPE :
Types de données C++ fondamentaux, tels que
int,charetfloatStructures et classes C++
Autres types que vous définissez
Pour plus de commodité et d’efficacité, vous pouvez utiliser le paramètre ARG_TYPE pour spécifier le type d’arguments de fonction. En règle générale, vous spécifiez ARG_TYPE comme référence au type que vous avez nommé dans le paramètre TYPE . Par exemple :
CArray<int, int> myArray;
CList<CPerson, CPerson &> myList;
Le premier exemple déclare une collection de tableaux, myArrayqui contient **int**s. Le deuxième exemple déclare une collection de listes, myList, qui stocke des objets CPerson. Certaines fonctions membres des classes de collection prennent des arguments dont le type est spécifié par le paramètre de modèle ARG_TYPE . Par exemple, la Add fonction membre de la classe CArray prend un argument ARG_TYPE :
CArray<CPerson, CPerson &> personArr;
CPerson person;
personArr.Add(person);
Utilisation simple de la carte
La classe de mappage simple, CMap, prend quatre paramètres : KEY, ARG_KEY, VALUE et ARG_VALUE. À l'instar des classes de tableau et de liste, les classes de table peuvent stocker n'importe quel type de données. Contrairement aux tableaux et listes, qui indexent et classent les données qu'ils contiennent, les tables associent des clés et des valeurs. Vous accédez à une valeur stockée dans une table en spécifiant la clé qui lui est associée. Le paramètre KEY spécifie le type de données des clés utilisées pour accéder aux données stockées dans la carte. Si le type de KEY est une structure ou une classe, le paramètre ARG_KEY est généralement une référence au type spécifié dans KEY. Le paramètre VALUE spécifie le type des éléments stockés dans la carte. Si le type de ARG_VALUE est une structure ou une classe, le paramètre ARG_VALUE est généralement une référence au type spécifié dans VALUE. Par exemple :
CMap<int, int, MY_STRUCT, MY_STRUCT &> myMap1;
CMap<CString, LPCTSTR, CPerson, CPerson &> myMap2;
Le premier exemple stocke les MY_STRUCT valeurs, les accède par int clés et retourne les éléments accessibles MY_STRUCT par référence. Le deuxième exemple stocke des valeurs CPerson, y accède par des clés CString et retourne les références aux éléments accédés. Cet exemple peut représenter un carnet d'adresses simple où vous recherchez des personnes par leur nom de famille.
Étant donné que le paramètre KEY est de type CString et que le paramètre KEY_TYPE est de typeLPCSTR, les clés sont stockées dans la carte en tant qu’éléments de typeCString, mais sont référencées dans des fonctions telles que SetAt des pointeurs de typeLPCSTR. Par exemple :
CMap<CString, LPCTSTR, CPerson, CPerson &> myMap;
CPerson person;
LPCTSTR lpstrName = _T("Jones");
myMap.SetAt(lpstrName, person);
Utilisation de modèles de collection de pointeurs typés
Pour utiliser les modèles de collection de pointeurs typés, vous devez connaître le type de données pouvant être stockées dans ces collections et les paramètres à utiliser dans les déclarations de collection.
Tableau de pointeurs typés et utilisation de liste
Le tableau de pointeurs typé et les classes de liste, CTypedPtrArray et CTypedPtrList, prennent deux paramètres : BASE_CLASS et TYPE. Ces classes peuvent stocker n’importe quel type de données, que vous spécifiez dans le paramètre TYPE . Ils sont dérivés de l’une des classes de collection nontemplate qui stocke les pointeurs ; vous spécifiez cette classe de base dans BASE_CLASS. Pour les tableaux, utilisez CObArray ou CPtrArray. Pour les listes, utilisez CObList ou CPtrList.
En effet, lorsque vous déclarez une collection basée sur CObList, non seulement la nouvelle classe hérite des membres de sa classe de base, mais elle déclare également plusieurs opérateurs et fonctions membres de type sécurisé qui aident à assurer la cohérence des types en encapsulant des appels aux membres de la classe de base. Ces encapsulations gèrent toutes les conversions de type nécessaires. Par exemple :
CTypedPtrArray<CObArray, CPerson *> myArray;
CTypedPtrList<CPtrList, MY_STRUCT *> myList;
Le premier exemple déclare un tableau de pointeurs typés, myArray, dérivé de CObArray. Le tableau stocke et retourne des pointeurs vers des objets CPerson (où CPerson est une classe dérivée de CObject). Vous pouvez appeler n’importe quelle CObArray fonction membre, ou appeler la nouvelle fonction de type-safe GetAt et ElementAt les fonctions ou utiliser l’opérateur type-safe [ ] .
Le deuxième exemple déclare une liste de pointeurs typés, myList, dérivée de CPtrList. La liste stocke et retourne des pointeurs vers des objets MY_STRUCT. Une classe basée sur CPtrList est utilisée pour stocker des pointeurs vers des objets non dérivés de CObject. CTypedPtrList a plusieurs fonctions membres de type sécurisé : GetHead, GetTail, RemoveHead, RemoveTail, GetNext, GetPrev et GetAt.
Utilisation du mappage de pointeur typé
La classe map de pointeur typé, CTypedPtrMap, prend trois paramètres : BASE_CLASS, KEY et VALUE. Le paramètre BASE_CLASS spécifie la classe à partir de laquelle dériver la nouvelle classe : CMapPtrToWord, , CMapPtrToPtr, CMapStringToPtrCMapWordToPtr, , CMapStringToOb, et ainsi de suite. KEY est analogue à KEY in CMap: il spécifie le type de la clé utilisée pour les recherches. VALUE est analogue à VALUE dans CMap: il spécifie le type d’objet stocké dans la carte. Par exemple :
CTypedPtrMap<CMapPtrToPtr, CString, MY_STRUCT*> myPtrMap;
CTypedPtrMap<CMapStringToOb, CString, CPerson*> myPersonMap;
Le premier exemple est une carte basée sur CMapPtrToPtr : elle utilise CString des clés mappées aux pointeurs vers MY_STRUCT. Vous pouvez rechercher un pointeur stocké en appelant une fonction membre de type sécurisé Lookup. Vous pouvez utiliser l’opérateur [ ] pour rechercher un pointeur stocké et l’ajouter s’il est introuvable. Vous pouvez également itérer la table à l'aide de la fonction de type sécurisé GetNextAssoc. Vous pouvez également appeler d'autres fonctions membres de la classe CMapPtrToPtr.
Le deuxième exemple est une carte basée sur CMapStringToOb : elle utilise des clés de chaîne mappées pour les pointeurs stockés vers CMyObject des objets. Vous pouvez utiliser les mêmes membres de type sécurisé décrits dans le paragraphe précédent, ou vous pouvez appeler des membres de la classe CMapStringToOb.
Remarque
Si vous spécifiez un ou struct un class type pour le paramètre VALUE, plutôt qu’un pointeur ou une référence au type, la classe ou la structure doit avoir un constructeur de copie.
Pour plus d’informations, consultez How to Make a Type-Coffre Collection.