static_cast use to convert int to char

Question

I have written this code to convert Decimal to binary:

string Solution::findDigitsInBinary(int A) {
if(A == 0 )
    return "0" ;
else
{
string bin = "";
while(A > 0)
{
    int rem = (A % 2);
    bin.push_back(static_cast<char>(A % 2));
    A = A/2 ;
}    
reverse(bin.begin(),bin.end()) ;
return bin ;
}
}

But not getting the desired result using static_cast.

I have seen something related to this that is giving the desired result :

(char)('0'+ rem).

What's the difference between static_cast? why I am not getting the correct binary output?

Zebrafish · Accepted Answer · 2018-03-12T01:38:30.497

With:

(char) '0' + rem;

The important difference is not the cast, but that the remainder, which always results in 0 or 1, is added to the character '0', which means that you adding a character of '0' or '1' to your string.

In your version you are adding either the integer representation of 0 or 1, but the string representations of 0 and 1 are either 48 or 49. By adding the remainder of 0 or 1 to '0' it gives a value of either 48 (character 0) or 49 (character 1).

If you do the same thing in your code it will also work.

string findDigitsInBinary(int A) {
    if (A == 0)
        return "0";
    else
    {
        string bin = "";
        while (A > 0)
        {
            int rem = (A % 2);
            bin.push_back(static_cast<char>(A % 2 + '0')); // Remainder + '0'
            A = A / 2;
        }
        reverse(bin.begin(), bin.end());
        return bin;
    }

Basically you should be adding characters to the string, and not numbers. So you shouldn't be adding 0 and 1 to the string, you should be adding the numbers 48 (character 0) and 49 (character 1).

This chart might illustrate better. See how the character value/digit '0' is 48 in decimal? Let's just say you wanted to add the digit 4 to the string, then because decimal 48 is 0, then you would actually want to add the decimal value of 52 to the string, 48 + 4. This is what the '0' + rem does. This is done automatically for you if you insert a character, that is, if you do:

mystring += 'A';

It will add an 'A' character to your string, but what it's actually doing in reality is converting that 'A' to decimal 65 and adding it to the string. What you have in your code is you're adding decimal numbers/integers 0 and 1, and these aren't characters in the Unicode/ASCII representation.

Now that you understand how characters are encoded, to cast an integer to a char does not change the decimal/integer to its character representation, but it changes the data type from int to char, a 4-byte data type (most likely) to a 1-byte data type. Your cast did the following:

After the modulo % operation you got a result of either 1 or 0 as an integer, let's just say you got a 1 remainder, it would look like this as an int:

00000000 00000000 00000000 00000001

After the cast to a char it would convert it to a one-byte data type, which would make it look like this:

00000001 // Now it's a one-byte data type

Whereas what a '1' digit looks like encoded as a string character is 49, which looks like this:

00110000

As for the difference between static_cast and c-style cast, the static_cast does compile-time checks and allows casts between certain types based on particular rules, whereas a c-style cast isn't as restrictive.

char a = 5;
int* p = static_cast<int*>(&a); // Will not compile
int* p2 = (int*)&a; // Will compile and run, but is discouraged as there are risks.
*p2 = 7; // You've written past the single byte char into 3 extra bytes, which is an access violation, or undefined behaviour.

static_cast use to convert int to char

1 Answers1