Pourquoi ne puis-je pas static_cast entre char et unsigned char *?

Apparemment, le compilateur considère être sans rapport avec les types et donc reinterpret_cast est nécessaire. Pourquoi est-ce la règle?

  • Je prends le SHA-1 hash d'une chaîne de caractères. c_str() renvoie une const char * et le SHA-1 fonction prend un const unsigned char * comme argument.
  • Et qu'attendez-vous d'arriver si cette chaîne contient caractère négatif des valeurs?
  • J'attends une valeur négative, c pour devenir c + 256, comme c'est la norme dans la conversion d'un octet signé pour un unsigned un. Honnêtement, je suis juste de faire la conversion pour calculer une valeur de hachage. Je n'aime pas la façon dont ils sont convertis, tant qu'ils sont convertis de la même façon à chaque fois.
  • La conversion d'un char à un unsigned char est une conversion. La conversion de char * à unsigned char* et puis la lecture les éléments en supposant qu'ils ont été convertis lorsqu'ils n'ont pas, c'est très différent. Il fonctionne sur un système où la conversion n'est pas réellement nécessaire un changement dans la représentation (par exemple, sur l'un deux, le système du complément), mais comme c'est une mise en œuvre spécifique de l'hypothèse qu'il est approprié qu'un explicite reinterpret_cast est nécessaire.
InformationsquelleAutor Nick | 2012-04-14
  1. 30

    Ils sont complètement différents types de standard:

    3.9.1 types Fondamentaux [de base.fondamentaux]

    1 des Objets déclarés comme des caractères char) doivent être assez grandes pour
    stocker n'importe quel membre de la mise en œuvre du jeu de caractères de base. Si un
    caractère de ce sous-ensemble est stocké dans un objet personnage, l'intégrale
    la valeur de ce caractère de l'objet est égale à la valeur de l'unique
    littéral de caractère de caractère. Il est
    mise en œuvre-définir si un char objet peut contenir négatif
    des valeurs. Les caractères peuvent être déclarées explicitement signés ou non

    signé. Plaine char, signed char et unsigned char sont
    trois types distincts.     Un char, un signed char et unsigned char
    occuper le même espace de stockage et ont le même alignement
    exigences (de base.types), c'est qu'ils ont le même objet
    la représentation. Pour les types de caractères, tous les bits de l'objet

    la représentation de participer à la valeur de la représentation. Pour unsigned
    les types de caractères, tous les modèles de bits de la valeur de la représentation
    représenter des nombres. Ces exigences ne sont pas pour les autres types. Dans
    tout particulier de la mise en œuvre, un simple char objet peut prendre sur soit
    les mêmes valeurs que la signature d'un char ou unsigned char; celui qui est de l'
    la mise en œuvre définies.

    De manière analogue, c'est aussi pourquoi la suivante échoue:

    unsigned int* a = new unsigned int(10);
int* b = static_cast<int*>(a); //error different types

    a et b sont complètement différents types, vraiment ce que vous êtes en questionnement est pourquoi static_cast de manière restrictive quand il peut effectuer les opérations suivantes sans problème

    unsigned int a = new unsigned int(10);
int b = static_cast<int>(a); //OK but may result in loss of precision

    et pourquoi ne peut-il pas en déduire que les types de cibles sont les mêmes bits largeur de champ et peut être représentée? Il peut le faire pour les types scalaires, mais pour les pointeurs, à moins que la cible est dérivée de la source et vous souhaitez effectuer un abattu alors la conversion entre les pointeurs n'est pas d'aller travailler.

    Bjarne Stroustrop états pourquoi static_cast's sont utiles dans ce lien: http://www.stroustrup.com/bs_faq2.html#static-cast mais sous une forme abrégée, il appartient à l'utilisateur d'indiquer clairement quelles sont leurs intentions et à donner le compilateur l'occasion de vérifier que ce que vous avez l'intention peut être atteint, car static_cast ne prend pas en charge la conversion entre les différents types de pointeur puis le compilateur peut intercepter cette erreur d'alerter l'utilisateur et si ils veulent vraiment faire de la conversion, ils utilisent reinterpret_cast.

    • thx pour énoncer la norme ici. Je ne l'ai pas disponibles.
    • Donc, si ils sont de deux types distincts, pourquoi le compilateur permettre la distribution unsigned char a = 255; char b = static_cast<char>(a); ?
    • la même raison, vous pouvez static_cast de chambres doubles ints et dans l'autre sens, ce que vous ne pouvez pas faire est de static_cast double* int*, les types de pointeur sont différentes, mais vous pouvez convertir une valeur à une autre avec l'inconvénient qu'il peut y avoir une perte de précision
    • hmm, semble comme une bête règle. Comme je l'ai mentionné dans ma réponse à Tobias, il semble que le que, le temps d'un static_cast devraient être autorisés sur le tableau/pointeur types doivent être de même largeur, primitives, sinon vous pourriez accidentellement tirer dans le pied (comme dans l'exemple que j'ai donné). Au moins avec la même largeur, primitives, rien ne peut aller mal.
    • Il peut surprendre les gens quand ils apprennent que vous ne pouvez pas static_cast entre unsigned char* et char*, mais il est fondamentalement parce qu'ils sont de types différents, nous ne sommes pas surpris que vous pouvez statique de la fonte entre les types comme floats à ints, et en fait, unsigned char à char, mais static_cast est ce qu'il fait de l'avantage évident par rapport à c-style jette est que vous obtenez de la compilation des erreurs si vous essayez de convertir entre les différents types, comme dans votre cas, il est lié à tant de poster: stackoverflow.com/questions/2473628/...
    • dans ce cas, c'est évidemment faux, mais, depuis int et double ont des largeurs différentes (et qui ne sont même pas représentés de la même manière!), donc, si vous lancez à double * vous pourriez accidentellement piétiner la mémoire si vous ne *d = 3.14. Mon utilisation de "ridicule" ne s'applique qu'à la même largeur primitives.
    • eh bien, c'est peut-être ridicule pour vous, mais c'est là un autre exemple static_cast n'est pas possible entre unsigned int* et int* qui est analogue à votre question, le stockage et la largeur est la même pour les deux, mais static_cast détecte au moment de la compilation qu'ils sont tous les deux différents types
    • Même avec int et float. Ils peuvent avoir la même taille, mais si vous avez une int, puis essayez de le lire comme un float, puis ce que vous obtenez dépend exactement comment float est stockée dans la mémoire. Et depuis la spécification ne dire comment float est stocké dans la mémoire, le cahier des charges pas définir ce qu'est le int ressemble. Rappelez-vous: Le C++ standard existe pour fournir des garanties au sujet de ce que vous obtenez. Afin de définir ce comportement, le standard aurait du détail comment float est mis en mémoire, ainsi que la façon dont int est mis en mémoire.
    • En bref: vous êtes à la confusion entre le concept de "ce qui se passe sur les machines réelles" avec "ce que le cahier des charges exige."
    • La spécification ne dis pas que le bit le plus significatif doit être le bit de signe, de sorte qu'une mise en œuvre pouvait-il en être le bit le moins significatif. Si c'était le cas, lorsque le compilateur a été coulée d'un unsigned char avec la valeur 1 à un signed char, il le saurait-il nécessaire de décaler les bits à gauche 1 pour tenir compte du bit de signe. Mais avec un unsigned char* et char*, c'est pas le casting du travail pour ajuster les valeurs à l'emplacement du pointeur. Il ne serait pas savoir combien de caractères à régler de toute façon.
    • La partie de la norme citée dans cette réponse me rappelle de git page de man de générateurs.
    • static_cast est une chienne bien, permettant pour les inconditionnels de sortie dans l'arbre de dérivation.
    • downvoter soin d'expliquer?

    InformationsquelleAutor EdChum
  2. 8

    vous essayez de convertir sans rapport avec les pointeurs avec un static_cast. Ce n'est pas ce static_cast est pour. Vous pouvez voir ici: La Conversion De Type.

    Avec static_cast vous pouvez convertir des données numériques (par exemple, char, unsigned char devrait fonctionner) ou un pointeur vers les classes connexes (liées par un héritage). C'est à la fois pas le cas. Vous voulez convertir un sans rapport avec pointeur à l'autre de sorte que vous avez à utiliser reinterpret_cast.

    Fondamentalement, ce que vous essayez de faire est pour le compilateur la même chose que d'essayer de convertir un char * à un void *.

    Ok, voici quelques réflexions supplémentaires pourquoi le fait de permettre ceci est fondamentalement mauvais. static_cast peut être utilisé pour convertir les types numériques les uns dans les autres. Donc, il est parfaitement légal d'écrire ce qui suit:

    char x = 5;
unsigned char y = static_cast<unsigned char>(x);

    ce qui est possible aussi: les

    double d = 1.2;
int i = static_cast<int>(d);

    Si vous regardez ce code en assembleur, vous verrez que le second cast n'est pas une simple ré-interprétation de la séquence de bits de d, mais au lieu de cela quelques instructions en assembleur pour les conversions sont insérées ici.

    Maintenant, si nous prolongeons ce comportement à des tableaux, le cas où tout simplement une manière différente d'interpréter la séquence de bits est suffisante, il pourrait fonctionner. Mais ce que sur le casting des tableaux de doubles à des tableaux d'entiers?
    C'est là que vous devez déclarer que vous simple voulez une ré-interprétation de modèles de bits - il y a un mécanisme appelé reinterpret_cast, ou vous devez faire un peu de travail supplémentaire. Comme vous pouvez le voir simple extension de la static_cast de pointeur /tableaux n'est pas suffisant, car il doit se comportent de manière semblable à static_casting valeurs des types. Cela a parfois besoin de plus de code, et il n'est pas clairement définissable comment cela doit être fait pour les tableaux. Dans votre cas - arrêt à \0 - parce que c'est la convention? Ce n'est pas suffisant pour les non-chaîne de cas (nombre). Ce qui va se passer si la taille des données-type de changements (par exemple, int vs double sur x86-32 bits)?

    Le comportement que vous souhaitez ne peuvent pas être correctement définie pour tous les cas d'utilisation c'est pourquoi il n'est pas dans la norme C++. Sinon, vous n'avez plus à vous rappeler des choses comme: "je peux lancer ce type à l'autre tant qu'ils sont de type entier, et de même largeur,...". De cette manière, il est tout à fait clair - soit ils sont liés à des CLASSES - ensuite, vous pouvez lancer les pointeurs, ou ils sont des types, alors vous pouvez lancer les valeurs.

    • J'ai reconnu dans mon message d'ouverture que le compilateur dit qu'ils sont sans rapport avec les pointeurs. Ce que je veux savoir, c'est pourquoi. Il me semble que si T1 est "liée" à T2, puis T1 * doit être "lié" à T2 *. Pourquoi n'est-ce pas que de taper la règle du son (pour les types primitifs)?
    • il n'est pas "quelque peu lié" mais "classes associées". Comme vous l'avez dit, char et unsigned char sont primitifs et non des classes. C'est la raison pour laquelle - et c'est ce que j'ai dit si vous avez lu attentivement. Vous avez raison - si la classe T1 est liée à la classe T2, alors vous pouvez utiliser static_cast pour convertir T1* au T2*. Ce n'est pas ce que vous faites. char n'est pas liée à unsigned char dans le sens de la relation requis par la norme C++.
    • Toutefois, si vous déposez le pointeur, le compilateur n'a aucun problème de conversion entre tous les types primitifs, par exemple unsigned char a = 255; char b = static_cast<char>(a); Il semble un peu étrange, car si T1 et T2 sont des classes, la distribution entre les pointeurs n'est pas saine, car vous pourriez faire quelque chose comme: class A; class B : public A; B *b = new B[4]; b[0] = B(); A *a = static_cast<A *>(b); a[1] = A(); B b1 = b[1]; // oops Il semble que le que moment de la fonte devrait être en sécurité est entre les types primitifs.
    • oui - et le comportement qui est clair et bien défini. Vous avez quelques règles sur la façon de convertir un type numérique dans l'autre. Cela peut être aussi facile que de copier la séquence de bits dans la mémoire ou aussi compliqué que la conversion d'un double, d'un int. Encore -c'est seulement pour une seule valeur, et donc facilement définissable. Voir mon explication ci-dessus. Le static_cast a 2 totalement différentes utilisations selon que le type est un type pointeur ou pas. Ils devraient avoir nommé differntly pour les 2 cas d'utilisation (par exemple, static_cast & numerical_cast).
    InformationsquelleAutor Tobias Langner
  3. 4

    En plus d'être des pointeurs, unsigned char * et char * n'ont rien en commun (EdChum déjà mentionné le fait que char, signed char et unsigned char sont de trois types différents). On pourrait dire la même chose pour Foo * et Bar * types de pointeur de toute dissemblables structures.

    static_cast signifie qu'un pointeur du type de source peut être utilisé comme un pointeur du type de destination, ce qui nécessite un sous-type de relation. Par conséquent, il ne peut pas être utilisé dans le contexte de votre question, ce que vous avez besoin est soit reinterpret_cast qui fait exactement ce que vous voulez ou un style C cast.

    InformationsquelleAutor Michael Foukarakis