Dupliqué possible:
Quand utiliser STD :: Taille_T?Bonjour.
En supposant que les modèles d'utilisation sont les mêmes (c'est-à-dire aucun chiffre négatif), qui est préférable à utiliser pour divers index,
int ouTaille_t type?Y a-t-il une différence de performance dans votre expérience sur Intel 64 bits entre les deux?
merci
4 Réponses :
Les types ne sont pas différents dans le sens que vous impliquez, et généralement En outre, vous devez noter que INT est signé, tandis que Taille_T n'est pas.
Enfin, int est 32bits et taille_t est la largeur du mot de la plate-forme (32-64 morceaux). Je vous suggère d'utiliser taille_t lorsque vous traitez avec des fichiers, des tampons et tout ce qui pourrait décrire une zone de mémoire ou un tampon.
int a été historiquement utilisé où taille_t doit être utilisé maintenant. Cependant, int est toujours utile dans son propre droit à d'autres fins.
Merci. J'essaie de normaliser dans mon projet de type particulier, d'améliorer les interfaces surtout, mais aussi de supprimer les avertissements du compilateur.
taille_t ou ptrdiff_t . int pourrait ne pas suffire à accéder à tous les éléments d'un tableau.
@ DAN04, il est fortement improbable que INT ne suffira pas. Plus important encore, c'est que les conteneurs standard utilisent Taille_T, et puisque INT est signé tant que Taille_T est non signé, vous pouvez obtenir des situations de comparaison entre types signés et non signés.
@Michael Aaron Safyan: tout à fait le contraire, int est essentiellement garanti d'être insuffisant en général, car il est signé , c'est-à-dire un bit pour le signe.
@Andreyt, en théorie, oui, mais dans la pratique, quand avez-vous vraiment un tableau de cette taille chargée dans la RAM? Si vous avez beaucoup chargé dans la RAM, il y a probablement quelque chose de mal à votre conception (vous devriez probablement être en streaming des données et utiliser des itérateurs), ou vous devriez vous inquiéter du type ... mais pour presque toutes les situations pratiques, vous allez à faire face à des tableaux beaucoup plus petits.
C'est comparer des pommes avec des oranges. Si " int n'est pas suffisant" est le problème, vous utiliseriez un long int . Taille_T et PTRDIFF_T Convey Semantitique Et c'est pourquoi ils doivent être utilisés ou non utilisés en fonction du contexte.
@Einpoklum: long int ne fonctionnera pas sur les plates-formes LLP64 comme MSVC ++. PTRDIFF_T est garanti de pouvoir stocker la différence entre deux pointeurs - ce qui est exactement ce qu'est un index de tableau est .
@ DAN04: bien, puis long long int . Même différence. Le point est que vous utiliseriez PTRDIFF_T - comme vous l'avez dit - pour la différence entre les pointeurs, non, par exemple, la différence entre la population actuelle de la planète de la planète et la population estimée à 1 000 CE.
@Einpoklum long int n'est pas garanti d'être plus grand que int , seulement pour être au moins aussi grand.
Cela dépend de ce que vous faites. Si vous êtes itération sur un vecteur, utilisez STD :: Taille_t: Toutefois, méfiez-vous des erreurs de codage tels que: Si vous faites une boucle, vous voudrez peut-être utiliser simplement une plaine de la situation en raison de la situation ci-dessus. Il ne devrait y avoir aucune différence de performance entre utiliser int et std ::ze_t. Si vous avez besoin d'une taille exacte, vous ne devez utiliser ni in int nize_t, mais plutôt les types définis dans STDINT.H .
Vous êtes itération sur un std :: vecteur <> (ou tout autre conteneur standard) que vous pourriez souhaiter utiliser std :: vecteur <> :: tad_type au lieu de raccourcissement directement à std ::ze_t .
@Andreyt, si l'on s'inquiète de généricité, il faut vraiment utiliser des itérateurs. Si on sourit une fonction rapide qui itière sur un vecteur, il n'y a rien à gagner de plus Verbose STD :: Vector :: Taille_Type au lieu de STD :: Taille_T.
Il se manquera peut-être quelque chose ici, mais pourquoi la deuxième boucle est-elle encore infinie?
Oh je viens de voir ça ... Size_t est non signé. nvm.
Lorsque vous travaillez avec un tableau spécifique , c'est-à-dire un tableau contenant des éléments spécifiques spécifiques à votre application, vous devez normalement avoir déjà un "type de choix" pour compter ou indexer les entités de ce type dans votre application. C'est le type que vous devez utiliser. Par exemple, si un tableau contient des enregistrements pour les employés de la société, vous devez déjà avoir un "type de choix" dans votre programme que vous utilisez pour désigner la "quantité d'employés". C'est le type que vous devez utiliser pour les tableaux d'indexation des enregistrements d'employés. Il pourrait être Remarque En outre, que Taille_t est le type qui doit être utilisé pour l'indexation de la matrice lorsque vous travaillez avec des tableaux de génériques relativement . C'est à dire. Lorsque vous avez juste un tableau d'abstrait char S, int s ou autre chose.
non signé INT , il pourrait être employé_count_t ou quelque chose comme ça. Utilisation d'un size_t à cette fin est une erreur de conception.
taille_t est un type non destiné à l'indexation de la matrice. C'est un type destiné à représenter la taille de l'objet le plus important du programme. Il "fonctionne" pour les tableaux par transitivité: les tableaux sont des objets, donc Taille_t est toujours suffisant pour indexer un tableau. Cependant, lorsque vous concevez un programme, il est plus logique de penser en termes de conteneurs génériques , au lieu de penser en termes de matrices spécifiques . Aujourd'hui, il pourrait s'agir d'une matrice, demain, vous devrez peut-être passer à une liste liée ou à un arbre. En général, la plage de taille_t n'est pas suffisante pour représenter le nombre d'éléments dans un conteneur abstrait, c'est pourquoi taille_t dans de tels cas n'est pas un bon choix. < / p>
@Andreyt, si demain, il pourrait s'agir d'une liste liée ou d'un arbre, un index de tout type n'est pas bon. Pour cela, vous avez besoin d'itérateurs.
@Michael Aaron Safyan: Pas nécessairement. Il est possible de construire une gamme segmentée de quelque sorte, pour laquelle le concept d'index est toujours logique et qui n'est néanmoins pas limité par la taille maximale d'un bloc de mémoire continue.
@Andreyt, mais les listes liées ne prennent pas en charge l'accès aléatoire ... Cela devient très piraté et aura probablement une très mauvaise performance. La solution la plus générale consiste à utiliser des itérateurs ou des visiteurs. Les indices ne font aucun sens pour les conteneurs d'accès aléatoire.
@Michael Aaron Safyan: Tout d'abord, comme je l'ai dit, on peut construire un conteneur à accès aléatoire , qui n'est pas limité de la taille du bloc de mémoire contiguë maximal, une "matrice segmentée" étant un exemple. Deuxièmement, si la performance des indices avec des listes est bonne ou non dépend du contexte. Ils pourraient être trop lents pour un accès direct de routine, mais ils pourraient être nécessaires pour la sérialisation.
@Michael Aaron Safyan: Tout d'abord, ils seraient nécessaires à la sérialisation dans une seule (sinon la seule) approche viable des références sérialisées dans une liste liée. Les pointeurs sont convertis en indices et à Vise Versa. Deuxièmement, personne ne parle que vous parlez de faire des fonctions API (comme opérateur [] ) à cette fin. Mon point est simple: l'indexation est absolument nécessaire lorsque vous travaillez avec des listes liées dans certains contextes, et il n'y a rien d'inefficace sur l'indexation des listes liées si elles sont correctes.
@Michael Aaron Safyan: C'est exactement ce dont je parle: vous pouvez simplement garder un comptoir lorsque vous entrez dans la liste. Maintenant, revenons à la question originale: quel type allez-vous utiliser pour ce comptoir? Tout ce que je dis, c'est que, en général cas, taille_t n'est pas suffisant.
@Cha merci, je n'ai pas trouvé ce post auparavant.