3. int, char usw.

int, char usw.

  • R

    Verstehe ich nicht. Was ist mit schlechtes Programm?

    0
  • C

    Naja ich will damit sagen, dass das mit der limit.h ja die schöne Lösung ist. Dies kam allerdings noch in keiner Vorlesung vor, deswegen die Frage wie man es mit Schleifen, if usw... lösen kann...wenns denn geht

    0
  • C
    Mod

    tja für integer könnte man einfach ne schleife bauen, die die zahl jedesmal um 1 erhöht und die solange läuft, bis man wieder die ursprüngliche zahl erreiccht hat, und nebenbei die größte und kleinste zahl speichern. umständlich, überflüssig ja... wenn man berits weis, wie integer gespeichert werden, könnte man auch 1 << 1 solange ausführen, bis 0 herauskommt, das ergebnis davor bezeichnet dann die kleinste und ihr einerkomplement die größte zahl. ohne schleife währe (~(char,short,long etc.)0)>>1 die größte und (((char,short,long etc.)0)>>1) die kleinste zahl.

    für floats wirds etwas schieriger... man könnte versuchen 1/0.0 bzw -1/0.0 zu rechnen und dann die resultierende unendlichkeit in die größtmögliche darstellbare zahl umwandeln.

    0
  • C

    Also das mit 1<<1 funktioniert perfekt, aber das mit dem float ?
    Wie kann man die resultierende Unendlichkeit in die größtmögliche Zahl umrechnen ?

    0
  • P

    Es erscheint mir extrem unwahrscheinlich, dass nach einer schlechten Lösung gesucht wird, solange in der Aufgabenstellung nicht explizit steht: "Es darf nur aus der Vorlesung Bekanntes benutzt werden."

    Ich würde den Aufgabenstellern keine Bösartigkeit unterstellen.

    0
  • C
    Mod

    für float/double geht das hier:

    double f = 0.0, power = 1.0, f2;
			double inf = 1 / f;
			while ( power < inf )
			{
				f = power;
				power *= 2;
			}
			power = f2 = f;
			while ( f2 < inf )
			{
				f = f2;
				power /= 2;
				f2 += power;
			}
			printf( "%.16e", f );

    zunächst wird die grösste zweier-potenz gesucht, die kleiner als unendlich (in diesem format) ist. dann werden solange kleinere potenzen addiert, bis ein überlauf zu unendlich auftritt (denn die grösste zahl ist ja 1.11111111...e+... im binärsystem) - wenn man will, kann man in der zweiten schleife noch mitzählen und so die genauigkeit des zahlenformats ermitteln.
    die kleinste zahl ist einfach die entgegengesetzte zahl.

    0
  • E

    Für Integer vielleicht in dem Stil:

    #include <iostream>

int main() 
{ 
    std::cout << "unsigned short     " << static_cast<unsigned short>     (-1) << std::endl; 
    std::cout << "unsigned long      " << static_cast<unsigned long>      (-1) << std::endl; 
    std::cout << "unsigned long long " << static_cast<unsigned long long> (-1) << std::endl; 
}
    0
  • I

    Für die Ganzen Zahlen:

    #include <iostream>
using namespace std;

template<class T>
void showRange(const char* type,  T t) {
   cout << "Range of " << type << ":" << endl;
   cout << "Unsigned = [0, " << static_cast<unsigned>(((1 << sizeof(t)*8) - 1)) << "]" << endl; 
   cout << "Signed   = [-" << (1<<((sizeof(t)*8)-1)) << ", " << ((1<<(sizeof(t)*8)-1)-1) << "]" << endl << endl;
}

int main() {
   char c=0;
   short s=0;
   int i=0;
   long l=0;
   bool b=0;

   showRange("char" , c);
   showRange("short", s);
   showRange("int" , i);
   showRange("long", l);
   showRange("bool", b);

   std::cin >> i;
}
    0
  • C

    Cool Danke für die Tipps, funktioniert alles super, sogar auf mehrere Methoden jetzt.
    Ihr seid die besten. 🤡

    0
  • ?

    interpreter schrieb:

    ((1<<(sizeof(t)*8)-1)-1)

    😮 😮 😮
    Wie kommt man auf sowas?

    0
  • W

    @C++Neuling: Das kann man sich ziemlich einfach überlegen. Weißt du denn, was der <<-Operator und sizeof hier bedeuten?

    0
  • ?

    MaSTaH schrieb:

    @C++Neuling: Das kann man sich ziemlich einfach überlegen. Weißt du denn, was der <<-Operator und sizeof hier bedeuten?

    << schiebt ein bit nach links oder?? Aber wie komm ich dadurch auf die Variablengrenzen?

    0
  • G

    C++Neuling schrieb:

    << schiebt ein bit nach links oder??

    Fast. Wieviel Bits mit << (oder auch >>) geschoben werden, bestimmt der rechte Operand. Wobei man hier vorsichtig sein sollte, speziell wenn der linke (also zu schiebende) Operand vom Typ her signed ist, denn das Ergebnis von negativen Werten ist implementationsspezifisch. Diverse Compiler arbeiten dann arithmetisch und nicht, wie vielleicht erwartet, logisch.

    C++Neuling schrieb:

    Aber wie komm ich dadurch auf die Variablengrenzen?

    Schau dir mal die interne Struktur von Ganzzahlen (oder auch Fliesskommazahlen) an, also auf Bitebene. Dann kannst du dir die Frage relativ einfach selbst beantworten.

    0
Anmelden zum Antworten