Mir ist bis jetzt nur ein ziemlich aufwendiger Weg eingefallen.
Man legt eine Menge von Integern an.
Man beginnt damit I1 hochzuzählen, läuft I1 über wird I2 um Eins erhöht, und so weiter bis I2 auch überläuft, jetzt wird I3 um eins erhöht und so weiter....

thxia

Wenn du 'nur' mit übergroßen Zahlenbereichen hantieren willst, solltest du mal nach GMP suchen - das ist eine Spezialbibliothek für (fast unbegrenzt) große Zahlentypen.

Wenn niemand dafür eine Lösung hat, lasse ich eben diesen Fortschrittsbalken einfach weg.

naja
danke für die Antworten^^

ne, danke für die Antworten, ich hab den Balken einfach weggelassen, da wars sogar schneller

Aber wenn in ferner Zukunft schließlich die Sonne erlischt, zeigt der Fortschrittsbalken so um die 10% an, und darum gehts hier ja schließlich.

"Vielen Dank, daß Sie 'Intelligentes Leben' gespielt haben. Noch eine Runde?"

selbst wenn dein Prozess nur aus dem Inkrementieren eines Riesen-Integers besteht, wirst du in deiner Lebensspanne 2^2000 nicht erreichen.

100 schrieb:

das programm würde länger laufen als du lebst. ist dir das klar?

von solchen Detail-Problemen sollte man sich als echter Hacker nicht aus der Ruhe bringen lassen

Hier ist mein Vorschlag:

#include <iostream>
#include <string>
#include <iterator>
#include <vector>
#include <limits>
#include <iomanip>
#include <sstream>
#include <algorithm>
#include <cassert>

class HyperCounter
{
public:
    explicit HyperCounter( double mant = 0.0, int exp10 = 0 ) // zahl = mant(isse) 10^exp10
        : m_digits( 1, '0' )
    {
        if( mant == 0.0 )
            return;
        assert( mant > 0.0 );
        // --   normalisieren
        while( mant >= 1.0 )
        {
            mant /= 10.0;
            ++exp10;
        }
        while( mant < 0.1 )
        {
            mant *= 10.0;
            --exp10;
        }
        assert( exp10 > 0 );

        using namespace std;
        ostringstream buf;
        buf << setprecision( min( exp10, std::numeric_limits< double >::digits10 ) ) << mant;
        const string zahl = buf.str();
        vector< char > digits( exp10, '0' );
        copy( zahl.begin() + zahl.find( '.' ) + 1, zahl.end(), digits.rbegin() );
        swap( digits, m_digits );
    }

    HyperCounter& operator++()
    {
        for( std::vector< char >::iterator i = m_digits.begin(); i!= m_digits.end(); ++i )
        {
            if( ++*i <= char('9') )
                return *this;
            *i = '0';
        }
        m_digits.push_back('1');
        return *this;
    }

    bool operator==( const HyperCounter& b ) const
    {
        return m_digits == b.m_digits;
    }
    bool operator!=( const HyperCounter& b ) const { return !(*this == b); }

    friend std::ostream& operator<<( std::ostream& out, const HyperCounter& hc )
    {
        std::copy( hc.m_digits.rbegin(), hc.m_digits.rend(), std::ostream_iterator< char >( out ) );
        return out;
    }
private:
    std::vector< char > m_digits;
};

int main()
{
    // 2^2000 ca.= 1,1481306952742545242328332011777 E+602
    const HyperCounter upper_limit( 1.1481306952742545242328332011777, 602 ); 

    HyperCounter hc;
    for( int cnt = 1; hc != upper_limit; ++hc, ++cnt )
        if( cnt % 924271 == 0 )   // cnt dient nur der beschleunigten Ausgabe
        {
            std::cout << hc << '\r';
            cnt = 0;
        }
    return 0;
}

Im Release-Mode übersetzt lässt es schon nach weniger als 10Sek MAX_INT hinter sich.

Gruß
Werner

aber ich hoffe, dass das jetzt nicht für mich geschrieben war :D, denn wie gesagt ich hab einfach den Balken weggelassen.....

@ Gott (ich meine den unregistrierten User, nicht den Herrn, der da irgendwo oben sitzt )

wenn du mich fragst: wir kommen nicht bei den 10 Mrd. Jahren an: irgendwann in 10-20 Jahren, kommt ein großes fettes "GAME OVER" auf dem Monitor^^
oder unser Server, von nicht PC-irren gerne auch mal schlampig als "Erde" bezeichnet, stürzt mit einem Bluescreen ab.