Ist das korrekt wenn am Ende des Codes, die Variable foo den Maximalwert haben soll? (Ich hasse diese Bitweise-Op's)

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

MfG, EOutOfResources

(mit deinem Code landest du vermutlich bei -1 (das höchstwertige Bit eines int ist typischerweise das Vorzeichen))

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.

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

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.

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);

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.

#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

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.

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.