3. Integergrenze?

Integergrenze?

  • S

    1 char == 1 byte != 8 Bit
    denn wieviel bit ein byte hat, ist nicht vorgeschrieben.

    normalerweise nimmt man typedefs um die größen richtig verwenden zu können.

    zB könnte unter windows folgendes gelten:

    typedef int16 short;
typedef int32 int;
typedef int64 __int64;

    dann musst du immer nur die richtigen typedes setzen und es läuft auf allen systemen...

    0
  • T

    Und jetzt dürfen alle (HilfeHilfe) mal raten, warum es so einfach ist C-Programme zu portieren. (Java läuft überall auf der selben virtuellen Maschine) Und dann fragt man sich weiterhin, warum es so etwas wie size_t oder uint_16 gibt. [edit]Da war Shade of Mine schneller[/edit]

    0
  • ?

    jetzt langsam macht ihr mir angst

    1 char == 1 byte != 8 Bit

    also 1 Byte hat schon 8 Bit oder!!!!

    0
  • T

    hilfehilfehilfe schrieb:

    jetzt langsam macht ihr mir angst

    1 char == 1 byte != 8 Bit

    also 1 Byte hat schon 8 Bit oder!!!!

    Mindestens!!!!! (Gewonnen)

    Nein, ein Byte sind schon 8 Bit, aber das hat ja nicht unbedingt sehr viel mit einem char zu tun.

    Five exclamation marks, the sure sign of an insane mind.
    Terry Pratchett

    0
  • ?

    Entschuldigung für die viele Fragerei aber trotzdem:

    1 Char muss also nicht zwingend 1 Byte = 8 Bit haben sondern kann auch größer sein???!??? Nochmals zusammenfassen: Grenzen von Variablen können auf jeder Maschine anders sein. Es gibt so ne Art Standard aber der muß nicht gelten. Warum macht man nicht einfach fix Grenzen aus die auf jeder Maschine gelten? Das wär doch viel einfacher nicht????

    0
  • C

    Nein. Wenn die Maschine z.B. 9 Bits pro Byte hat, wäre es Verschwendung es auf 8 zu fixieren. Ok, 16 ist vielleicht realistischer als 9. Aber da wäre die Verschwendung sogar noch größer.

    Natürlich gibt es einen Standard und genau definierte Grenzen:
    Siehe ganz oben, 1. Antwort (die von tobidope):

    #include <limits>

int max_int = std::numeric_limits<int>::max();
    0
  • S

    tobidope schrieb:

    Nein, ein Byte sind schon 8 Bit, aber das hat ja nicht unbedingt sehr viel mit einem char zu tun.

    Nein, ein char ist schon 1 Byte, aber das hat ja nicht unbedingt sehr viel mit 8 Bit zu tun.

    Ich bin mir nicht sicher ob mindestens 8 Bit verlangt sind, aber ich glaube schon. Architekturen mit nur 7 Bit pro Byte, müssen dies halt emulieren.

    Und was spricht gegen ein 16Bit Byte?

    0
  • T

    Dann sagen wir es mal so, ein char muss mindestens ein Byte/8 Bit sein, aber sizeof(char) ist immer == 1. Jetzt sind alle Klarheiten beseitigt.

    0
  • S

    Nein.

    Ein char ist ein byte welches mindestens 8 bit haben muss.

    0
  • ?

    Wenn ich mich da mal einmischen darf: Sicher kannst du nur sagen, dass

    sizeof(short) <= sizeof(int) <= sizeof(long) <= sizeof(long long) (long long nur bei C99)

    Analog gilt

    sizeof(float) <= sizeof(double) <= sizeof(long double)

    Ein Byte sind seit den späten Sechzigern immer 8 bit, davor war das nicht standardisiert. Wenn du also irgendwo ne alte Z1 ausgräbst, die macht das möglicherweise anders. Donald Knuth beschreibt die Problematik in "The Art of Computer Programming, Vol I". Der MIX, den er vor der Standardisierung des Bytes entwickelt hat, arbeitet mit 6-bit-bytes in der binären und 2-bit-bytes in der dezimalen Version (Ein MIX-Byte kann mindestens 64 Zustände aufnehmen).

    Was char angeht - nach ANSI hat ein char 1 byte. Allerdings weiß niemand, ob sich das in zukünftigen C/C++-Standards ändern wird; immerhin steht UCS (Unicode) schon seit einer ganzen Weile in den Startlöchern,

    Dass ein Integer Werte bis 65535 aufnehmen könne, ist inzwischen veraltet. In der Zeit der 16-bit-Prozessoren und kurz danach (16/32-bit-Hybridprozessoren) waren ints oft auf 16 bit beschränkt. Das entsprach einem Maximalwert von 32767 bzw. 65535 für unsigned ints. Inzwischen ist das aber überflüssig geworden, so dass man auch normale ints in 32-bit-Register packt, die bis zu 4 Milliarden und ein paar zerquetschten Zuständen aufnehmen können. Dementsprechend ändern sich auch die Bereiche, die eine Variable aufnehmen kann. Etwas vergleichbares steht uns übrigens unmittelbar bevor; zukünftige Prozessoren werden 64-bit-Register haben, was die Grenze auf 2^65-1 (36.893.488.147.419.103.231, 36,89 Trillionen) anhebt.

    0
  • ?

    Also wenn dein Program unter Win32 läuft dann gilt dies:
    1 Byte hat 8 Bit
    sizeof(char)=1Byte
    sizeof(short)=2Byte
    sizeof(int)=4Byte
    sizeof(long)=4Byte
    sizeof(long long)=8Byte

    Welche Zahl in welchen unsigned Type passen kanst du folgerdermassen herausfinden:
    0 bis 256^Bytes-1
    Und für signed Typen:
    -(256^Bytes)/2 bis (256^Bytes)/2-1

    0
Anmelden zum Antworten