[C] Getal groter als short als input, erg ?

[Joshua822]

Hallo allemaal.

Iedereen die C heeft geleerd kent dat kleine programma waarin de gebruiker om een getal wordt gevraagd wel. Maar is het ook veilig ? Stel dat ik de gebruiker vraag om een unsigned short ( de maximumwaarde is in limits.h vastgelegd op +65535 voor dit type variabel ), maar hij / zij een te groot getal, bijvoorbeeld 1000000 geeft. Kan dit kwaad ? Zal er dan geschreven worden op een geheugenlocatie waar het niet bedoeld is ( bijvoorbeeld in het geheugen van een ander programma, of op het opvolgend element in een array ).

Zo ja, kan dit dan voorkomen worden, in een programma als dit :

Code: [Selecteer]

#include <stdio.h>

short i;

void set_memory ( char * memory_block, unsigned short value, int size_of_block );

int main ()
{
  unsigned short user_input[3];
  printf ( "Give three short integer numbers : " );
  scanf ( "%d", user_input[0] ); scanf ( "%d", user_input[1] ); scanf ( "%d", user_input[2] );
  printf ( "The following numbers have been stored : %d %d %d \n", user_input[0], user_input[1], user_input[2] );
  if ( user_input[0] > user_input[1] && user_input[0] > user_input[2] )
    set_memory ( ( char * ) user_input, user_input[0], 3 );
  else if ( user_input[1] > user_input[0] && user_input[1] > user_input[2] )
    set_memory ( ( char * ) user_input, user_input[1], 3 );
  else
    set_memory ( ( char * ) user_input, user_input[2], 3 );
  getchar ();
  return 0;
}

void set_memory ( char * memory_block, unsigned short value, int size_of_block );
{
  for ( i = 0; i < size_of_block; i++ )
    memory_block[i] = value;
}
Alvast bedankt.

[commandoline]

Zelf heb ik geen ervaring met C, maar als ik me niet vergis gaat de short nadat er meer wordt opgeteld dan die max-waarde terug naar 0, en wordt wat er nog resteert bij die nul opgeteld.

[Mossie]

Zelf heb ik geen ervaring met C, maar als ik me niet vergis gaat de short nadat er meer wordt opgeteld dan die max-waarde terug naar 0, en wordt wat er nog resteert bij die nul opgeteld.

Klopt helemaal. Ik heb het net even getest met 2 kleine testprogrammaatjes. De hoogste 16 bits vallen gewoon weg.

[Joshua822]

Is het ook mogelijk om dan gewoon te zorgen dat als het getal groter is dan 65535 het array element gewoon de waarde 65535 krijgt ?

[Mossie]

Dat is wel mogelijk, maar dan moet je inlezen in een int, en dan controleren of de waarde groter is dan USHRT_MAX, en dan het array item de invoerwaarde of USHRT_MAX te geven.

[ertai]

ehm.. overflow's in C zijn niet goed.. deze worden niet afgevangen en schrijven gewoon verder.. dus je overschrijft andere waardes. Dit moet je dus zeker omvormen..

[Joshua822]

ehm.. overflow's in C zijn niet goed.. deze worden niet afgevangen en schrijven gewoon verder.. dus je overschrijft andere waardes. Dit moet je dus zeker omvormen..

Heeft dit wel iets te maken met een overflow ? Een overflow is toch als er meer waardes naar een array geschreven worden dan er in die array kunnen zitten ?

[Rachid]

Heeft dit wel iets te maken met een overflow ? Een overflow is toch als er meer waardes naar een array geschreven worden dan er in die array kunnen zitten ?

Onder andere

[ertai]

als je het niet netjes afvangt dan zijn het denk ik wel overflow's en schrijf je gewoon verder. (denk ik.. lang geleden dat ik in C heb geprogt.. dus weet het niet zeker meer)

[_san]

Heeft dit wel iets te maken met een overflow ? Een overflow is toch als er meer waardes naar een array geschreven worden dan er in die array kunnen zitten ?

Onder andere

Om het even simpel te houden, het is gewoon een waarde aan een adres toekennen die groter is dan de capaciteit. Bijvoorbeeld een unsigned char (0-255) de waarde 591313545 geven. Ik denk dat je het beste getchar kunt gebruiken als je een 'oneindige' buffer wilt.

EDIT: voorbeeld toegevoegd.

Code: [Selecteer]

#include <stdlib.h>
#include <string.h>
#include <stdio.h>

char * str = 0;

void __exit ( void );

int main ( void )
{
char c = 0;
int i = 0;

atexit ( __exit );

while ( 1 ) {
if ( ( c = getchar ( ) ) != '\r' && c != '\n' ) {
i++; str = realloc ( str, sizeof ( char ) * i );
str [ i - 1 ] = c; str [ i ] = 0;
printf ( "str: %s (%d)\n", ( char * ) str, i );
}
}

return 0;
}

void __exit ( void )
{
if ( str ) {
free ( str );
}
}

Net even getest en het werkt zoals het zou moeten werken!

[Joshua822]

Het probleem is dat dit inderdaad een oplossing is voor het werken met strings, maar niet voor shorts limiteren tot hun maximale waarde.

[_san]

Het probleem is dat dit inderdaad een oplossing is voor het werken met strings, maar niet voor shorts limiteren tot hun maximale waarde.

Waarom niet?

In je 1e post is het probleem dat je bang bent dat iemand een te groot getal intikt. Als je met chars werkt (zoals je in mijn voorbeeld ziet) hoef je je hier geen zorgen meer om te maken, maar heb je toch dezelfde uitkomst.