La bibliothèque sur laquelle je travaille doit être utilisée sur les machines 32 et 64 bits; J'ai beaucoup d'avertissements de compilateur car sur des machines 64 bits Y a-t-il des inconvénients dans le remplacement de tous les Unsigned int! = Taille_t .
non signé INT s et Taille_t S par 'non signé long "? J'apprécie que cela n'a pas l'air très élégant, mais dans l'affaire, la mémoire n'est pas trop d'un problème ... Je me demande s'il y a une possibilité de bugs / comportement indésirable, etc. Créé par ce remplacer Toutes les opérations (pourriez-vous donner des exemples)? Merci.
4 Réponses :
Si vous utilisez Exemple: remplacer size_t dans les endroits où vous devrait obtenir un size_t et le remplacer par avec non signé long , vous allez introduire de nouvelles avertissements. Taille_t avec non signé long et (à Le degré qu'ils sont différents) Vous aurez introduit un nouvel avertissement (car quelque_vector.size.size () renvoie un Taille_t - réellement un std ::: quelque chose > ::ze_type mais en pratique, il devrait évaluer à la même chose).
Je pourrais avoir plus d'avertissement, vrai, mais je peux en haublir d'induire un véritable problème (par exemple bug)?
@Yuccav dans n'importe quel programme qui se prend sérieusement, les avertissements sont des problèmes intéressants.
Cela dépend de votre code. Si vous avez - pour un autre exemple - des différences de compensation calculées et que vous les comparez à moins de zéro, vous pouvez obtenir des négatifs de manière non signée, ce qui devrait se situer quelque part près de la plage maximale de la valeur non signée de ce type peut représenter (0x11111111 ou similaire). Cela dépend de votre basebase fondamentalement. Le point d'Angew est valide cependant: votre meilleur pari est de définir votre compilateur pour avoir une ollertance zéro pour les avertissements (pour GCC, c'est l'option -werror ).
La norme donne peu de garanties sur les tailles de types tels que Il est parfaitement possible pour une plate-forme de définir Un autre critère à considérer est que int et long . Taille_T est garanti d'être suffisamment grand pour contenir n'importe quel objet, et tous les conteneurs std fonctionnent sur Taille_t . .
long comme plus petit que taille_t ou avoir la taille de long sous réserve des options de compilation, car Exemple. Pour être sûr, il est préférable de rester à taille_t .
ze_t porte une signification - "Cette chose est utilisée pour stocker une taille ou un index." Il rend le code légèrement plus auto-documentant.
Quels avertissements? Le plus évident que je puisse penser est pour une "conversion de rétrécissement", c'est-à-dire que vous affectez L'inconversion principale de remplacer Le correctif approprié est que si vous attribuez un Inversement, si vous avez une variable qui n'a pas besoin d'être suffisamment grosse pour contenir une taille, il suffit de suffisamment grand pour Les deux types ( taille_t à non signé int et d'avertir que l'information pourrait être perdu.
taille_t avec non signé long est que non signé long n'est pas garanti pour contenir toutes les valeurs possibles de taille_t et sur Windows 64, il n'est pas assez grand. Donc, vous pourriez trouver que vous avez toujours des avertissements.
taille_t à une variable (ou membre de données), vous devez vous assurer que la variable a un type suffisamment grand pour contenir n'importe quelle valeur de taille_t < / code>. C'est ce que l'avertissement est tout. Donc, vous ne devez pas passer à non signé long , vous devez activer ces variables vers Taille_t .
non signé INT , alors n'utilisez pas Taille_t Pour cela, en premier lieu.
taille_t et non signé INT ) ont des utilisations valides, donc toute approche qui remplace indiscriminalement toutes les utilisations par un autre type doit Soyez faux :-) En réalité, vous pouvez tout remplacer avec Taille_t ou uintMax_t et pour la plupart des programmes qui seraient OK. Les exceptions sont les endroits où le code s'appuie sur l'utilisation d'un type non signé de la même taille que int ou autre, tel qu'un type plus grand brise le code.
Ce peut être un problème de supposer qu'il est non signé longuement lorsque longtemps est de 8 octets. alors (non signé INT) -1! = (non signé long) -1, le code suivant peut avoir une défaillance d'affirmation.
unsigned int i = string::npos; assert(i == string::npos);
Si, à un moment donné, la spécification des bibliothèques change et
Taille_T est signée, vous aurez beaucoup de problèmes.Quelle est la probabilité de cela se produire? Taille_t est censé représenter une adresse mémoire ...
Un inconvénient est que sur 64 bits Windows
Taille_T estnon signé long long long carlong est de 32 bits (même en mode 64 bits).Pourquoi ne pas faire le contraire et remplacer toutes les occurrences pertinentes par
std ::ze_t ?@YUCCAV non, pointeurs (et
intPTR_T , d'une manière) sont censés représenter des adresses.Taille_T représente des tailles d'objet ou des indices dans des objets (tableaux).@Konrad bien, parfois nous avons besoin de longs
@Yuccav, outre ce que Angew a dit, peut-être dans le futur Taille_t deviendra 128 bits et vous vous retrouverez avec le même problème. Toute la raison de
taille_t est pour vous ne pas vous inquiéter de type utilisé en interne par le conteneur.@Spook Iso C nécessite
Taille_T en tant que type d'entier non signé. Vous n'aurez presque rien à travailler si cela est changé pour être signé.