"Operators and Casts" questions

latchkeykid · March 1st, 2010, 09:34 PM

The following code is given as an example of where implicit conversion fails (Chapter 6, pg. 149).

Code:

byte value1 = 10;
byte value2 = 23;
byte total;
total = value1 + value2;

Quote:

The problem here is that when you add 2 bytes together, the result will be returned as an int, not as another byte. This is because a byte can contain only 8 bits of data, so adding 2 bytes together could very easily result in a value that cannot be stored in a single byte.

OK, that makes sense, but why does it then allow you to do the same with ints? Replace the byte with int in the preceding code block and it compiles. Couldn't the same "data loss" happen with the sum of two ints?

My second question is about boxing. Say you are calling a custom (overridden) ToString() method on a user-defined struct, if this is still boxed, why is there a performance benefit associated with overriding the ToString() method?

By the way, fantastic book! I've already learned so much.

sh_erfan · March 29th, 2010, 09:25 PM

Hi.

I wanna say sth about your first question.

The book gives you the answer.

It says when you add 2 bytes the result is returned as an integer (an inner behavior of C#). It means that the result of (value1 + value2) is an integer.
So can you assign an integer to a byte? Of course not.Because integer is a larger data type. What is the solution?
You simply need an explicit conversion of int to byte (look at the error) and then assign it to total.
try this:

Code:

byte v1 = 10;
byte v2 = 23;
byte total;
total = (byte)(v1 + v2);

when you add two integers the type of returned value do not change to other types. It is again integer. Because of that,you don't need any conversion.

Hope that helped.

Erfan...

latchkeykid · March 29th, 2010, 10:50 PM

Thanks for the reply.

Regarding your example code, understood, the code sample without the explicit cast was taken from the book (it was used as an example of where implicit conversion fails).

My point was simply that, why does it protect against overflow by placing the sum in a larger data type for bytes, yet does not do this for int32?

Actually, after thinking about this more, it is probably because for the byte type, C# does not by default check for overflows (therefore it stores their sum in a larger data type). C# allows you to add two int32s into an int32 data type because an overflow throws an exception. I guess the developer is responsible for handling possible run-time overflows.

For example:

Code:

int k = 2147483647;
k++;

throws an exception.

Am I barking up the right tree?