Impression des valeurs hexadécimales pour console en C++

#include <iostream>
#include <iomanip>

using namespace std;

int main()
{
    char array[10];

    for(int i = 0; i<10;i++)
    {
        array[i] = 'a' + i;
    }

    char* test = array;

    printf("%x\n", test);
    cout << hex << test << endl;

}

La sortie est la suivante:

bffff94e
abcdefghijN???

Pourquoi n'est-il pas l'impression est la même chose?

Si vous souhaitez imprimer un pointeur, vous devez utiliser %p avec printf(), %x est un entier hexadécimal non signé. Comme %x, std::hex ne fonctionne pas comme vous l'attendez avec des pointeurs, il vise à être utiliser avec partie intégrante des valeurs numériques.

OriginalL'auteur ordinary | 2012-06-19

  1. 6
    cout << hex << test << endl;

    Il affiche la chaîne de caractères, et non pas l'adresse. C'est parce qu'il y a une surcharge de operator<< qui prend char const* comme argument et cette surcharge traite l'argument comme une chaîne de caractères.

    Si vous souhaitez imprimer l'adresse, la fonte de l'argument de void* de sorte que autres surcharge de operator<< sera invoqué, ce qui permet d'imprimer l'adresse.

    cout << hex << static_cast<void*>(test) << endl;

    va imprimer l'adresse, au format hexadécimal.

    Noter que hex stream-manipulateur n'est pas nécessaire ici, l'adresse sera imprimée au format hexadécimal anway. Donc 

    cout << static_cast<void*>(test) << endl;

    est assez.

    Serait &test au lieu de (void *) test pas le travail tout aussi bien (et un peu moins intimidant pour un [peut-être] les nouveaux programmeur)? (Pardonnez-moi si je me trompe ici; je ne travaille pas en C++ trop.)
    Oui....Je devrais travailler.
    Mal. &test imprime quelque chose d'autre. Votre exemple utilise un array, pas pointeur, c'est pourquoi cela fonctionne, mais l'OP utilise un pointeur. Merci aussi de se débarrasser de ces C-style jette. Nous avons un large consensus pour dire qu'ils ne devraient pas être utilisés, ce qui les rend encore plus dangereux dans l'enseignement de la matière (= ici).
    Juste pour mémoire, je n'ai rien contre le style C jette dans ce cas précis (mais en général, je les limiter à des valeurs numériques, et de les bannir sur les pointeurs---de les accepter pour (void*) dans une déclaration de sortie est une exception.
    Notez que la réponse est fausse pour plusieurs raisons. Pour commencer, et plus important encore, vous devriez vraiment signaler que l'original a plusieurs cas de comportement indéfini. Et d'autre part, il n'y a aucune garantie que la sortie d'un pointeur de résultat en hexadécimal. J'ai travaillé sur les machines où il a été octal, et sur l'une des plus répandues machines a quelques années, il avait le format XXXX:XXXX (où XXXX est hexadécimal). Et le hex modificateur n'est pas nécessaire d'avoir un effet sur void*; vous pourriez obtenir octal même avec elle.

    OriginalL'auteur Nawaz

  2. 6

    Parce que votre programme a un comportement indéfini. Et parce que vous le demandez
    imprimer des choses différentes.

    Votre invocation de printf est illégal, et les résultats non défini
    comportement (et c'est un bon exemple de pourquoi vous devriez ne jamais les utiliser printf).
    Votre spécificateur de format dit à extraire une unsigned int de l'
    liste d'arguments et de sortie qui en hexadécimal. En passant rien, mais
    un unsigned int est un comportement indéfini. Il se trouve que, compte tenu de la façon
    varargs sont généralement mises en œuvre, si vous êtes sur une machine où
    unsigneds et les pointeurs ont la même taille, vous aurez probablement sortie de l'
    la valeur du pointeur, le traitement de ses bits comme si c'était un unsigned.
    D'autres comportements sont certainement possibles, cependant. (Si je ne me trompe pas,
    g++ avertir à propos de cette construction; il est également possible que sur certains
    les plates-formes, il va se planter.)

    Dans le cas de std::cout, vous êtes passig un char*. Par définition,
    le char* est traité comme un '\0' de la chaîne, pas comme un pointeur (et
    certainement pas comme un unsigned int). Et encore, vous avez pas défini
    comportement, depuis votre char* ne pointe pas vers un '\0' chaîne terminée;
    vous n'avez jamais mis un '\0' à la fin. (Ce qui explique sans doute la "N???"
    vous voyez à la fin de votre sortie. Mais encore une fois, un comportement indéfini est,
    eh bien, non défini. Le code pourrait tout aussi facilement être écrasé.)

    Enfin, vous utilisez les deux printf et std::cout; les résultats ne sont pas
    vraiment spécifié, sauf si vous faites une chasse d'eau de la rivière entre les deux.
    (Dans la pratique, si vous êtes de la sortie à un dispositif interactif, la chasse d'eau
    devrait se produire lors de la sortie des '\n' caractère. Si vous rediriger l'
    la sortie vers un fichier, cependant, vous êtes susceptible d'obtenir quelque chose de différent.)

    Il n'est pas clair ce que vous voulez. Si vous souhaitez copier l'adresse de
    array, ce serait:

    printf( "%p\n", test );
std::cout << static_cast<void*>( test ) << std::endl;

    Si vous voulez à la sortie de la chaîne de caractères que vous avez généré, puis ajouter un '\0' à
    la fin de celui-ci (sans débordement de la mémoire tampon), et puis:

    printf( "%s\n", test );
std::cout << test << std::endl;

    Je ne suis pas sûr de ce que vous essayez de faire "hex"; il n'y a pas une telle chose comme
    une représentation hexadécimale d'une chaîne de caractères, et la représentation d'un pointeur est
    la mise en œuvre définies, et pas besoin de prendre en compte toute
    paramètres de mise en forme dans iostream. (En général, sur la plupart des machines modernes,
    il sera hex. Mais j'ai travaillé sur plus de quelques cas où il serait
    octal, et au moins un endroit où il ne serait pas juste un nombre, quel que soit
    de la base.) Si vous souhaitez un vidage hexadécimal de array, vous aurez à boucle,
    la sortie de chaque valeur, comme un unsigned dans hex:

    for ( int i = 0; i < 10; ++ i ) {
    printf( "%x", static_cast<unsigned char>( test[i] ) );
}
printf( "\n" );
std::cout.setf( std::ios_base::hex, std::ios::basefield );
for ( int i = 0; i < 10; ++ i ) {
    std::cout << static_cast<unsigned>( static_cast<unsigned char>( test[i] ) );
}
std::cout.setf( std::ios_base::dec, std::ios::basefield );
std::cout << std::endl;

    Enfin: un mot sur la jette: plaine char peut être signé ou
    non signé; si elle est signée, en la convertissant en une int ou un
    unsigned, pourrait aboutir soit à une valeur négative (int) ou un très
    grande valeur positive (unsigned). Ainsi, la première conversion à
    unsigned char, ce qui garantit un résultat dans la gamme [0, UINT_MAX].
    Deuxièmement, bien sûr, nous devons convertir le unsigned char à unsigned:

    • dans le cas de printf, parce que nous aurions autrement ont pas défini
      le comportement, mais la conversion est implicite, puisque le passage d'une unsigned
      char       comme un vararg promeut automatiquement à unsigned; et

    • dans le cas std::cout, parce que les règles sont que n'importe quel caractère
      type de sortie est un personnage, non pas comme une valeur numérique (et depuis le
      type est utilisé ici en fonction de la résolution de surcharge, et n'est pas
      passé à un vararg ou un unsigned, il n'y a pas de conversion implicite).

    +1 pour l'explication détaillée indiquant tous les problèmes dans le code d'origine.

    OriginalL'auteur James Kanze

  3. 1

    test lui-même est un pointeur, c'est à dire qu'il stocke une adresse. Votre printf déclaration imprime la valeur hexadécimale de l'adresse.

    La cout << déclaration puis imprime la totalité de la chaîne, parce que le std::hex manipulateur n'affecte pas la façon dont les chaînes de caractères sont imprimés. Il n'affecte que les entiers sont imprimés.

    Ce que vous pouvez faire est de

    1. Boucle à travers les personnages du tableau
    2. Convertir chaque nombre entier et d'impression à l'aide de la std::hex manipulateur

    Qui ressemblerait à ceci:

    for (int i = 0 ; i < 10 ; ++i)
  std::cout << std::hex << static_cast<int>(array[i]) << '\n';

    OriginalL'auteur jogojapan

  4. 0

    cout << HEX <<

    ne peut pas être utilisé pour un char* pour imprimer un hex chaîne de char,
    mais vous pouvez l'utiliser pour int ,double,float,etc.

    Et, comme vous le deuxième impression, pourquoi la chaîne a certaines chaînes confuses, c'est que vous n'avez pas donné
    un '\n' à la chaîne qui signifie la fin de la chaîne de

    OriginalL'auteur canvas