[c++] Possible overflow in shift operation

[Verwijderd]

C++:

void CharToIntArray(char* CharArray, unsigned int* IntArray, int ArraySize)
{
  int iValue;
  char cValue;

  for (int i = 0; i < ArraySize; i++)
  {
    cValue = CharArray[i];
    iValue = cValue << 32;
    IntArray[i] = iValue;
  }
}

Bij het compileren van bovenstaande functie (die maakt van een Char Array een Int Array) geeft de compiler de volgende warning: W8055 Possible overflow in shift operation

loogies..! dat risico bestaat..! (Maar niet in mijn programma... neem dat maar even aan...)

Ik heb geen flauw idee hoe ik dit moet oplossen/ondervangen; Kan iemand mij een duw in de richting geven..? Of wellicht een betere manier om van een Char Array een int array te maken..

[curry684]

(Maar niet in mijn programma... neem dat maar even aan...)

Je zwetst.

[MrBucket]

Zeker weten doe ik 't niet, maar ik gok dat "iValue = cValue << 32" betekent dat 'ie een
shift zal doen op een byte - en dan schuif je dus idd alle bits eruit

Je variabele moet eerst gecast worden naar een int, zodat 'ie de shift zal doen op een doubleword: "iValue = (int)cValue << 32"

Maareh, als je 32 plaatsen schuift, schuif je nog alle bits eruit... (aangenomen dat een int 32 bits is dan)

[Verwijderd]

Disable met een #pragma

[MrBucket]

Oh wacht, NU snap ik pas wat je wil doen

Je hoeft helemaal niet met bits te gaan schuiven... je moet je variabelen gewoon casten:

C++:

for (int i = 0; i < ArraySize; i++) 
  { 
    cValue = CharArray[i]; 
    iValue = (int)cValue;      /* Dit is voldoende */
    IntArray[i] = iValue; 
  } 

iValue zal nu 32 bits groot zijn; de hoogste 24 bits worden 0, terwijl de laagste 8 overgenomen worden uit cValue.

[ Voor 17% gewijzigd door MrBucket op 04-07-2003 13:04 ]

[curry684]

MrBucket: hoeft niet eens te casten, char naar int is moeiteloos een impliciete conversie voor. Maar als iemand een topic start en van de grootste blunder in z'n programma zegt dat we maar even aan moeten nemen dat het correct is geef ik het niet aan hoor...

[Verwijderd]

Nou misschien is het handig als TS ff aangeeft wat hij nou echt wil bereiken. Ik zat te denken dat hij misschien wel zijn char in de hoogste byte van z'n DWORD wil plaatsten ipv laagste. In dat geval kan hij dat met shiften oplossen alleen dan geen 32 posities.

Overigens hoef je van char naar int niet te casten.

[Verwijderd]

Verwijderd schreef op 04 juli 2003 @ 13:16:
Nou misschien is het handig als TS ff aangeeft wat hij nou echt wil bereiken. Ik zat te denken dat hij misschien wel zijn char in de hoogste byte van z'n DWORD wil plaatsten ipv laagste. In dat geval kan hij dat met shiften oplossen alleen dan geen 32 posities.

Dit is inderdaad het geval.. Deze functie is een begin om informatie in een int op te slaan dus op 1e 2 posities haalt ie op uit bestand 1; de 2e 2 posities uit bestand 2 enz.. en de module van een collega van mij moet een intarray hebben die die info bevat..

Die 32 was inderdaad een slordigheidje van mijn kant; excuus daarvoor.. even snel en voorbeeldje ingeklopt..

[curry684]

Het is nog steeds volledig onduidelijk wat je nu wil. Moet er op intarray[5] hetzelfde staan als op chararray[5] of wil je iedere int uit de intarray laten bestaan uit 4 bytes van de chararray?

[farlane]

Aangezien de shift voor de assignment gaat zal hij die char wel eerst naar int moeten casten.

Ook al was dat niet het geval, voor readability is het beter om haakjes te plaatsen.

[Verwijderd]

Ja..
Even in hex met een array van bijv: {0,1,2,4,16}
in het formaat:
[positie] = Chararray: intarray
[0] = 00 : 00 00
[1] = 01 : 01 00
[2] = 02 : 02 00
[3] = 04 : 04 00
[4] = 10 : 10 00

[curry684]

Dan zou het perfect moeten compileren zonder warnings als je die char cast naar een int en vervolgens 24 naar links shift.

[MSalters]

curry684 schreef op 04 July 2003 @ 12:32:
--------------------------------------------------------------------------------
(Maar niet in mijn programma... neem dat maar even aan...)
--------------------------------------------------------------------------------
Je zwetst.

Nou nou. Het zou kunnen dat hij alleen 0 << 32 doet, dan heb je geen overflow. Anders heb je wel gelijk. Dat is wel waarom de compiler er geen Error van mag maken.

[MSalters]

Verwijderd schreef op 04 July 2003 @ 13:59:
Ja..
Even in hex met een array van bijv: {0,1,2,4,16}
in het formaat:
[positie] = Chararray: intarray
[0] = 00 : 00 00
[1] = 01 : 01 00
[2] = 02 : 02 00
[3] = 04 : 04 00
[4] = 10 : 10 00

Afgezien van het praktische feit dat ints vaak 32 zijn, is het niet duidelijk of je
hier een LSB of een MSB machine bedoelt. Wil je dat de int array waardes
{ 0, 1, 2, 4, 16 } bevat of waardes { 0, 256, 512, 2046, 8192 } ?

In het eerste geval had ik er dit van gemaakt:

C++:

void foo( std::vector<char> const& vc, std::vector<int> & vi )
{
  vi = std::vector<int>( vc,begin(), vc.end() );
}

[curry684]

Nou nou. Het zou kunnen dat hij alleen 0 << 32 doet, dan heb je geen overflow. Anders heb je wel gelijk. Dat is wel waarom de compiler er geen Error van mag maken.

* curry684 quotes HHGTTG: "This is that thing you humans call 'sarcasm' again isn't it?"

[farlane]

curry684 schreef op 04 juli 2003 @ 15:58:
[...]

* curry684 quotes HHGTTG: "This is that thing you humans call 'sarcasm' again isn't it?"

HHGTTG ?
Komt me bekend voor maar wat was dat ook al weer ?

[Glimi]

offtopic:
HHGTTG = Hitchhiker's Guide to the Galaxy