Ik geloof dit het moet zijn:

csharp code - Bekijk de code zonder highlighting - Klap code in

byte k = (byte)(i * j);

byte k = (byte)(i * j);

 

Hoeveel is 255 * 255 dan? Dat past niet in een byte. Daarvoor heb je een short of int16 nodig.

dus dan moet int * int ook long worden zoals jij het beschrijft en dat is niet.

Zoals jerone al zei moet het. De bewerking van twee bytes geeft als resultaat een integer. Je moet dus het resultaat casten naar een byte, het resultaat mag dan wel niet groter zijn dan 255 natuurlijk. Voorbeeld:

csharp code - Bekijk de code zonder highlighting - Klap code in

byte result;
byte x = 5;
byte y = 7;
result = (byte)(x * y);
//geldt ook voor andere bewerkingen
//je kan ook met statische getallen werken
result = (byte)(9 + 4);
//je kan ook bijvoorbeeld doubles omzetten
//naar bytes door middel van deze casting
result = (byte)7.0;

byte result;
byte x = 5;
byte y = 7;
result = (byte)(x * y);
//geldt ook voor andere bewerkingen
//je kan ook met statische getallen werken
result = (byte)(9 + 4);
//je kan ook bijvoorbeeld doubles omzetten
//naar bytes door middel van deze casting
result = (byte)7.0;

 

Hopelijk een volledige en duidelijke uitleg! 

Misschien heb ik m'n vraag niet duidelijk gesteld. Je zei dus:

De bewerking van twee bytes geeft als resultaat een integer.

Hoe komt dit ? 

Is op zich het probleem opgelost? 
Dat is net hetzelfde als je een integer deelt door een integer en het resultaat is geen geheel getal:

csharp code - Bekijk de code zonder highlighting - Klap code in

double result;
int x = 5;
int y = 3;
result = x / y;
//result kan/mag geen integer zijn
//ook bij vermenigvuldigen is dit hetzelfde
//vrij logisch toch?!

double result;
int x = 5;
int y = 3;
result = x / y;
//result kan/mag geen integer zijn
//ook bij vermenigvuldigen is dit hetzelfde
//vrij logisch toch?!

 

Fout. Int is op Windows 32-bit standaard een int32. Dit is dus duidelijk een long. Op 64-bit is dit zelfs een int64 dat is een variant of in C++ een long long. Dit wordt nog niet door alle compilers geondersteund maar het bestaat wel. Omdat int32 * int32 een int64 kan zijn wordt dit nog behandeld als een long omdat int64 niet standaard geondersteund wordt door sommige compilers, daarbij kan dit niet echt standaard zijn op de 32-bit versie van een besturingssysteem. Alhoewel het bestaat en ook wel eens gebruikt wordt. Wat jij dacht was zeker dat int16 een int was. Dat zou enkel van toepassing zijn op een 16-bit besturingssysteem. int16 * int16 kan een long of een int(32) vereisen.

Titjes, ik had geen probleem, ik wou gewoon de theorie weten hoedat het komt dat een bewerking met twee bytes een integer wordt, ook al doe je byte 5 - byte 3.

Dus de compiler rekent met de geheugenruimte die voor elk type wordt vrijgegeven, dus twee bytes werkt met 2 keer 1 byte en heb je dus een type nodig van min 2 byte en daar nemen ze int32 voor. Maar waarom dan geen short?

De reden waarom ik dit wil weten, is omdat ik een vak "programeertechhieken" heb en die leerstof gaat over zulke dingen maar ze leggen niet goed uit hoe het komt, ze vragen ergens waarom je een fout krijgt als je twee bytes vermenigvuldigt zonder het naar INT te casten.

Omdat 255 * 255 > de waarde die een (signed) short kan bevatten. Mijn vermoeden is, als je het resultaat naar een unsigned short cast, dat je resultaat wel als short-type gebruikt wordt.

waar zit je wel op school misschien?
en rambo is trouwens juist