Même chose pour CMap, CList, et à peu près tout ce qui utilise des modèles (je suppose). Je trouve un peu difficile à comprendre quand utiliser quoi. Il est vrai que pour les classes et autres, le formulaire <class, class&> est généralement ce que vous voulez, mais pour les types de base comme int, float, etc., quelle forme est préférée?Quelle est la différence entre CArray <int, int> et CArray <int, int&>?
Je dirais que si vous n'avez pas vraiment besoin d'autre chose, utilisez simplement CArray<Type> et ARG_TYPE serait sa valeur par défaut const TYPE&. En fait, en utilisant Type& comme ARG_TYPE n'est pas une bonne idée. Cela permet théoriquement CArray de modifier l'objet/valeur que vous avez passé à la méthode correspondante. Bien sûr, CArray ne fait rien comme ça, mais il est préférable d'être du bon côté.
Si vous regardez le code source disponible dans MS VC, vous verrez que ARG_TYPE est utilisé dans quelques méthodes comme type d'argument qui contient une nouvelle valeur pour certains élément (s) du tableau tel que
void SetAt(INT_PTR nIndex, ARG_TYPE newElement)
INT_PTR Add(ARG_TYPE newElement)
void SetAt(INT_PTR nIndex, ARG_TYPE newElement)
void InsertAt(INT_PTR nIndex, ARG_TYPE newElement, INT_PTR nCount = 1)
Si vous de faire votre choix entre Type et const Type&, alors la seule chose qui est affecté est combien de fois et dont les données seraient copiées. Lorsque la valeur est passée par référence, seul le pointeur sur elle est réellement passé. Ceci est vraiment important pour les objets (appel additionnel du constructeur de copie) mais n'a pas vraiment d'importance pour les types simples. Bien sûr, vous pouvez essayer d'économiser quelques octets en forçant la copie char ou short qui est plus petit que le pointeur correspondant (32/64 bits selon la plate-forme), mais je ne pense pas que cela vaut vraiment la peine de problèmes supplémentaires. Comme je l'ai déjà dit, je pense que l'utilisation par défaut de CArray<Type> est un bon moyen, sauf si vous avez vraiment des raisons de le changer.
J'ai souvent eu la même question et je suis en train d'essayer de travailler sur un bug bizarre qui, je crois, est lié à cette différence. Je ne suis pas certain que je comprends très bien ce qui se passe encore, mais considère cette opération:
a.Add(a[0]);
Si un est déclaré comme CArray<int, int&>, alors il y a un cas de mauvaise qualité lorsqu'elle est trop petit pour l'addition et doit être cultivé. SetAtGrow() est appelée et crée une copie agrandie du tableau. Malheureusement, la référence à a [0] est maintenant une référence à la mémoire invalide puisque le tableau a été déplacé.
Si a est déclaré comme CArray<int, int>, une copie de [0] est transmise à la fonction Ajouter et il n'y a pas de problème. Encore une fois, j'essaie toujours de comprendre cela (c'est pourquoi j'ai fini par trouver cette discussion), mais il semble y avoir un problème subtil avec l'utilisation de références si jamais vous référencez votre propre CArray en effectuant une opération qui augmenterait sa taille. Vous ne pouvez pas faire confiance à la référence, donc CArray<int, int> semble préférable.