Donc, j'écris un programme pour tester l'endanianesse d'une machine et l'imprimer. Je comprends la différence entre Petit et Big Endian, cependant, de ce que j'ai trouvé en ligne, je ne comprends pas pourquoi ces tests montrent l'endanianesse d'une machine.
C'est ce que j'ai trouvé en ligne. Qu'est-ce que * (char *) & x signifie et comment cela équivaut-il à un prouve qu'une machine est petite-Endian? P>
6 Réponses :
Voici ce que la mémoire ressemblera à la mémoire, en supposant un entier 32b: Déroferience A Char * code> vous donne un octet. Votre test récupère le premier octet à cet emplacement de mémoire par
char * code> strong>, puis la déséroférance. P> P>
@Huntermcmillen pourrait être. Que veux-tu dire ?
Peut-être que je suis confus, utilisez-vous 0x80000000 code> comme adresse d'octet en mémoire?
@Huntermcmillen Je l'utilise pour représenter le nombre 2 ^ 31 code> dans la base 16.
@CNICUTAR: La valeur sera réellement stockée comme 0x01, 0x00, 0x00, 0x00, pas 0x80000000. Les bits ne sont pas inversés dans l'octet - juste l'ordre des octets stockés en mémoire.
Voir @sangeeth Saravanaraj's Répondre pour une meilleure description de la valeur de la valeur.
Si nous nous sommes séparés en différentes parties: P>
maintenant si nous revenons à Quelle est l'expression obtient le premier de ces octets et vérifiez s'il est & x code>: Ceci obtient l'adresse de l'emplacement où la variable
x code> est, c'est-à-dire
& x code> est un pointeur sur
x code>. Le type est
int * code>. P> li>
(char *) & x code>: Ceci prend l'adresse de
x code> (qui est un
int * code>) et le convertit un
char * code>. p> li>
* (char *) & x code>: cette déréférences Le
Char * code> pointé vers par
& x code>, c'est-à-dire que les valeurs stockées
x code>. p> li>
ol>
x code> et comment les données sont stockées. Sur la plupart des machines,
x code> est quatre octets. Stockage
1 code> dans
x code> définit le bit le moins significatif sur
1 code> et le reste à
0 code>. Sur une machine à petite Endian, elle est stockée en mémoire comme
0x01 0x00 0x00 0x00 code>, tandis que sur une machine Big-Endian, elle est stockée sous forme
0x00 0x00 0x00 0x01 Code>. P>.
1 code> ou non. p>
Briser * (char *) & x code>: p>
& x code> est l'adresse d'entier x p>
(char *) code> Les causes de l'adresse de l'entier x à traiter comme une adresse d'un caractère (AKA octet) P>
* code> fait référence à la valeur de l'octet p>
Évidemment, @ Joahcim Pileborg l'a expliqué mieux et plus rapide.
(*(char *)&x == 1)
Merci! J'ai une autre question rapide, si cela ne vous dérange pas. Will (Char *) & X Donne-moi une chaîne de l'adresse de x? En outre, comment puis-je obtenir la valeur de tous les bits individuels dans une variable? Un octet entier par dites.
Une définition lâche d'une c-string est - "Un ou plusieurs caractères (grièvers) (char) qui sont terminés par" \ 0 "". En C, une chaîne peut être représentée comme char x [] code> ou
char * x code>.
Pour les opérations de bits, reportez-vous à la référence Catonmat.net / Blog / Basse-niveau-bit-bit-bits-You-absolument-boit
Oui, cela répond à la question. Voici une réponse plus générale: ceci s'affiche
8
4
2
1
Pour les valeurs déréférencées chez C, C + 1, C + 2 et C + 3 respectivement.
La somme Y est 16909320, ce qui est égal à x. Même si la signification des chiffres grandir de droite à gauche, il reste encore peu d'Endian, car les valeurs de mémoire correspondantes se développent également de droite à gauche, c'est pourquoi l'opérateur binaire gauche-shift << Augmenterait la valeur d'une variable Jusqu'à ce que les chiffres non nuls sont décalés de la variable. Ne confondez pas cet opérateur avec STD :: Cout's's << Opérateur.
Si cela était grand Endian, l'affichage pour C, C + 1, C + 2 et C + 3 ressemblerait respectivement à:
1
2
4
8 p> p>
Si un integer non signé de Big-Endian Unsigné ressemble à 0xAabbccdd, ce qui est égal au 2864434397, alors que le même entier non signé de 4 octets non signé ressemble à 0xDDCCBBAA sur un processeur peu-endien qui est également égal à 2864434397.
si Un big-endian de 2 octets non signé ressemble à 0xAabb, ce qui est égal à 43707, puis que les mêmes 2 octets non signés ont ressemblé à 0xbbaa sur un processeur peu-endien qui est également égal à 43707. P>
ici sont quelques fonctions pratiques #define pour échanger des octets de petite-Endian à Big-Endian et vice-versa -> p>
Si vous "comprenez déjà" la différence entre grand et petit Endian, pourquoi est-ce qu'un test de base de l'endianesse n'est pas compréhensible?
Je sais ce que cela fait et que je ne suis pas tout à fait sûr pourquoi vérifier si une version déréférencée de la variable, jetée en tant que pointeur sur un charcuter vous le dira. À moins que l'endansion d'un caractère ne soit standard, auquel cas, cela vous dira s'il change pendant ce casting binaire.