如何从c中的数组打印char类型？

Question

int remainder;
char Hex[8];
int quotient, power;
remainder = (original_value*-1)-1;
for (int k = len; k > 0 ; k--)
{
    if (sign == 1)
    {
        power = pow(16, k-1);
        quotient = 15 - (remainder/power);
        remainder = remainder%power;
        if (quotient < 10)
            Hex[len - k] = (int)quotient;
        else if (quotient == 10)
            Hex[len - k] = 'A';
        else if (quotient == 11)
            Hex[len - k] = 'B';
        else if (quotient == 12)
            Hex[len - k] = 'C';
        else if (quotient == 13)
            Hex[len - k] = 'D';
        else if (quotient == 14)
            Hex[len - k] = 'E';
        else if (quotient == 15)
            Hex[len - k] = 'F';
    }
}


for(int k = 0; k < len; k++)
    printf("%s", Hex[k]);

I did not include the rest of the code, as this little bit should hopefully explain what I am trying to achieve. My goal is to print out a Base 16 representation of any number that is entered by a user, but I need to save this data into an array for later use, how do I print the data within my char array (The last two lines), such that the characters display as they do in my for loop?

Answer 1

try This hope this will work and enjoy

  printf("%s", Hex[k]); ==> printf("%c", Hex[k]);

And pow to elevate a power of 2 is really sub-optimal. You should use shifts (<<)

Answer 2

Some quick and dirty code to do this looks like this;

unsigned int somevalue = 3543577; 
char hexout[9];
const char *hexchar = "0123456789ABCDEF";
for(int i=7; i>=0; i--, somevalue >>= 4) 
    hexout[i] = hexchar[somevalue & 0xF];
hexout[8] = 0;

printf("%s\n",hexout);

Watch out for assumption on sizeof int etc.

Answer 3

You're making it much more difficult than it needs to be.

• Avoid using floating point - such as pow() - when working with integral types. It introduces a whole range of artifacts, due to limited precision of floating point. Use operations on integral types only.
• %s format requires a zero terminated string (array of char ). Hex[k] is a single character - which is a type mismatch. printf() gives undefined behaviour if the format specifier and the type of the corresponding argument don't match.

If you really must do this in a loop, the approach is simple. Note I'm assuming original_value is positive, and that you don't need to keep its original value.

char Hex[9];
const char hex_digits[] = "0123456789ABCDEF";
for (int i = 0; i < 8; ++i)
{
    Hex[7-i] = hex_digits[original_value % 16];
    original_value /= 16;   
}
Hex[8] = '\0';

The assumption that original_value is positive is vital because the modulo operator ( original_value % 16 ) will produce a value between 0 and 15 inclusive, and integer division ( original_value /= 16 ) rounds toward zero.

This will add leading zeros, so the output string for a value of 300 will be "0000012C". I'll leave it as an exercise to work out how to get leading spaces rather than leading zeros.

You can also do the above using equivalent bitwise operations, but I'll leave that as an exercise. I consider using basic math operations is clearer for this exercise (most people, if asked to write some value on paper in hex, would work in terms of division and remainders, not bit fiddling).

However, the above (even trying to do it in a loop) is unnecessary. All you really need to do is;

 char Hex[9];
 sprintf(Hex, "%08X", (unsigned)original_value);

If you want spaces instead of leading zeros, remove the 0 from the format string.

Note that I have increased the dimension of Hex by 1 . This allows for sprintf() to append a trailing zero (and prevents undefined behaviour, since sprintf() ASSUMES the array provided is large enough to include that trailing character). That will also allow you to print using

 printf("%s", Hex);

which keeps printing characters until a trailing zero byte is found.

If you don't want the trailing zero character in the array, obviously you need to adjust logic above. But you also need to avoid trying to print the array as a string (eg using the %s format).

Bear in mind that your question ASSUMES int is a 32-bit type (a larger array would be needed for 64-bit types, for example).