C Berechnung und Ausgabe der Wertebereiche

DarkDragN

Lieutenant
Registriert
Dez. 2005
Beiträge
881
Hallo! Im Rahmen einer Aufgabe sollen wir die Wertebereiche verschiedener int Deklarationen ausgeben. Das ganze funktioniert auch, bis auf unsigned long int. Hier mal der Code:

PHP:
#include <stdio.h>

int main()

{
  short int x = 1;
  long int y = 1;
  unsigned short int a = 1;
  unsigned long int b = 1;
  
  while(x>0){  /* Schleife die solange +1 addiert, bis der Wert unter 0 kippt */
             x=x+1;
             }
             
             printf("yoho %d\n",x);
             x=x-1;
             printf("yoho %d\n",x);
             
    while(y>0){
             y=y+1;
             }
             
             printf("yoho %d\n",y);
             y=y-1;
             printf("yoho %d\n",y);
     
    while(a>0){
             a=a+1;
             }
             
             printf("yoho %d\n",a);
             a=a-1;
             printf("yoho %d\n",a);
    
    while(b>0){ /* Das Problemkind. */
             b=b+1;
             }
             
             printf("yoho %d\n",b);
             b=b-1;
             printf("yoho %d\n",b);
             
  system("PAUSE");
  
  return 0;

}

Erwartet habe ich, dass er es, ähnlich wie bei unsigned short int, korrekt ausgibt, allerdings zeigt er mir nur 0 und -1 an. Ich habe bereits gelesen das die Grenzen auch in einer anderen Datei hinterlegt sind, allerdings möchte ich das schon gerne berechnen lassen.
 
DarkDragN schrieb:
PHP:
    while(b>0){ /* Das Problemkind. */
             b=b+1;
             }
             
             printf("yoho %d\n",b);
             b=b-1;
             printf("yoho %d\n",b);
}

Versuch mal

PHP:
    while(b>0){ /* Das Problemkind. */
             b=b+1;
             }
             
             printf("yoho %lu\n",b);
             b=b-1;
             printf("yoho %lu\n",b);
}
 
DarkDragN schrieb:
allerdings möchte ich das schon gerne berechnen lassen.
Dann berechne es doch auch. Einen Buffer Overflow zu provozieren halte ich für weniger gut. ;)

Formeln:

wenn unsigned:

min = 0
max = 2^(sizeof( Datentyp ) * 8) - 1

wenn signed:

min = -(2^( sizeof( Datentyp ) * 8) ) / 2)
max = 2^(sizeof( Datentyp ) * 8) / 2) - 1
 
Wo siehst du da einen buffer overflow? Integer overflow, ja, buffer overflow, nein. ;) http://en.wikipedia.org/wiki/Buffer_overflow

Übrigens, deine Methode funktioniert zwar in der Regel auch, die des OPs ist aber portabler als deine, da es tatsächlich auch einige exotische Platformen gibt, auf denen die kleinste adressierbare Einheit (Byte) nicht 8 Bits enthält. Die Bits pro Byte kann man übrigens mit dem #define CHAR_BIT aus dem Header limits.h abfragen.

P.S. Nicht daß das für diesen Anwendunsfall wirklich wichtig wäre .... ich wollt's nur mal erwähnt haben.


P.S. #2: Wenn man schon klugscheißt, sollte man es wenigstens richtig tun. :-( Ich bin mir nämlich gar nicht so sicher, ob das Verhalten bei einem integer overlfow vom Standard geregelt wird. Wenn nicht hätte sich das mit der angeblichen besseren Portabilität des ursprünglichen Ansatzes erledigt.
 
Zuletzt bearbeitet: (Rcehtschreipunk)
@DarkDragN: Was du da machst ist keine "Berechnung", sondern eher eine Art erschöpfende Suche. Yuuris Formeln treffen es schon präziser. Die Grundlagen davon kannst du in der binären Kodierung von ganzen Zahlen bei Prozessoren nachlesen. Die funktionieren nämlich _alle_ mit Zweierkomplement. Ob signed oder unsigned spielt bei Addition und Subtraktion deshalb keine Rolle. Es ist eine Frage der Interpretation durch das Programm.

Die angesprochene Datei ist übrigens limits.h. Auf deren Angaben kann man sich verlassen.
 
antred schrieb:
P.S. #2: Wenn man schon klugscheißt, sollte man es wenigstens richtig tun. :-( Ich bin mir nämlich gar nicht so sicher, ob das Verhalten bei einem integer overlfow vom Standard geregelt wird.
So oder so ähnlich passiert mir das auch immer mal. :D In C++ ist es undefiniertes Verhalten für signed, definiertes für unsigned. Gerade nachgeschaut - gleiches bei C. Zu dem Underflow finde ich gerade selber nix. *kopfkratz*
 
Zuletzt bearbeitet:
Die Spezifikation kannst du da erstmal zur Seite legen. Die Implementierung in Hardware gibt den Ausschlag. Die ist bei allen mir bekannten CPU-Baureihen die gleiche. Integer Overflow/Underflow ist oft ein Grund für Sicherheitlücken. Man kann damit Zeigerarithmetik umbiegen um beliebige Adressen zu erzeugen. Ist absolut teuflisch und zugleich bedauerlich, dass Compiler viele signed/unsigned Conversions ohne Warnung schlucken.
 
Zuletzt bearbeitet:
Zurück
Oben