3. Maximaler Wert

Maximaler Wert

  • E

    Oh, entschuldigung. Ich meinte natürlich:

    unsigned int foo; 
for(unsigned long int i = 0; i < sizeof int; i++) 
{ 
  foo <<= 8; 
  foo |= 255; 
}

    Somit bezieht sich meine Frage auf die Operatoren statt auf dem Aufbau von primitiven Datentypen.

    0
  • C

    In dem Fall könnte dir immer noch das hier einen Strich durch die Rechnung machen.

    0
  • E
     

    unsigned int foo; 
for(unsigned long int i = 0; i < sizeof int; i++) 
{ 
  foo <<= CHAR_BIT; 
  foo |= std::pow(2, CHAR_BIT) - 1; 
}

    EDIT: Obwohl volkard kein schlechtes Gewissen haben würde, wenn er 8 statt CHAR_BIT schreibt.

    0
  • V
     

    foo |= std::pow(2, CHAR_BIT)-1; //-1
    0
  • E

    Sind jetzt alle Bits von foo auf 1 gesetzt?

    0
  • C

    Da fehlt zwar noch ein -1, aber sonst dürfte der Ansatz funktionieren. Darf man erfahren, waru du dir überhaupt die Mühe machst, den maximal möglichen unsigned long Wert auszurechnen, wenn du die Antwort viel billiger bekommen könntest?

    0
  • E

    CStoll schrieb:

    Darf man erfahren, waru du dir überhaupt die Mühe machst, den maximal möglichen unsigned long Wert auszurechnen, wenn du die Antwort viel billiger bekommen könntest?

    Ja. Bei einem primitiven Typ wie diesem nutze ich natürlich weiterhin die STD. Aber es geht um Memory-Hacking die modifikation von komplexen Typen.

    0
  • I

    Eigentlich reicht doch ein simples ~0u . Oder habe ich jetzt ein Brett vor Augen?

    0
  • V

    EOutOfResources schrieb:

    Sind jetzt alle Bits von foo auf 1 gesetzt?

    Glaube nicht, weil ich std::pow nicht vertraue, das könnte einen Überlauf haben.

    Sagen wir mal so: unsigned-Typen rechnen so, wie Du es erwartest.

    Vielleicht geht

    foo |= ~static_cast<unsigned char>(0);
    0
  • V

    EOutOfResources schrieb:

    Aber es geht um Memory-Hacking.

    Dann mußt Du den fremden Speicher eh mit systemspezifischen Tricks aufmachen und kannst wesentlich lockerer an die Sache herangehen und erstmal von 8 Bit pro Byte und Zweierkomplementdarstellung ausgehen.

    0
  • V

    Zur Sicherheit trotzdem immer unsigned nehmen, wenn man schmuddeln will. Sonst "optimiert" der GCC manche Sachen auf erstaunlichste Weise weg.

    #include <iostream>
using namespace std;

int main(){
    char c=0;
    for(unsigned int i=1;i!=0;++i){
        if(!c++) cout<<i<<'\r'<<flush;
    }
}

    Klappt.

    #include <iostream>
using namespace std;

int main(){
    unsigned char c=0;
    for(unsigned int i=1;i!=0;++i){
        if(!c++) cout<<i<<'\r'<<flush;
    }
}

    Klappt auch.

    #include <iostream>
using namespace std;

int main(){
    unsigned char c=0;
    for(unsigned int i=1;i!=0;++i){
        if(!++c) cout<<i<<'\r'<<flush;
    }
}

    Klappt auch.

    #include <iostream>
using namespace std;

int main(){
    char c=0;
    for(unsigned int i=1;i!=0;++i){
        if(!++c) cout<<i<<'\r'<<flush;
    }
}

    Keine Ausgabe! 😮 😮 😮 😕 🙄 :p 😡 💡 😃 🤡

    0
  • C

    EOutOfResources schrieb:

    Ja. Bei einem primitiven Typ wie diesem nutze ich natürlich weiterhin die STD. Aber es geht um Memory-Hacking die modifikation von komplexen Typen.

    Dann würde ich nicht einmal davon ausgehen, daß du mit deiner Bit-Bastelei alles triffst, was du da hacken modifizieren willst. Und ich hoffe du weißt, was du da tust, weil dein Compiler dir dabei nicht helfen wird.

    0
  • C
    Mod

    0
  • C
    Mod

    EOutOfResources schrieb:

    unsigned int foo; 
for(unsigned long int i = 0; i < sizeof int; i++) 
{ 
  foo <<= CHAR_BIT; 
  foo |= std::pow(2, CHAR_BIT) - 1; 
}

    EDIT: Obwohl volkard kein schlechtes Gewissen haben würde, wenn er 8 statt CHAR_BIT schreibt.

    Wenn du hier CHAR_BIT brauchst, musst du auch damit rechnen, dass double exotisch genug ist und nicht genugt signifikante Stellen hat.

    0
Anmelden zum Antworten