#include <iostream>
#include <fstream>
#include <limits>
#include <string>
#include <sstream>
#include "ic.hpp"
using namespace std;
using namespace ic::shorties;

int main()
{
    hide();
    string file_name;
    ofstream file;
    ostringstream temp;

    for(int l=0;l<4000;l++)
    {
        temp << l;
        file_name="D:/Peng"+temp.str()+".txt";
        file.open(file_name.c_str(),ios::out | ios::app);
        for (int i=0;i<20000;i++)
        {
            for (int j=0;j<280;j++)
            {
                file << "Peng!";
            }
            file << "\n";
        }
        file.close();
    }

    return 0;
}

MfG
Stromberg

wenn der code so statisch bleibt, dann:

statt:

for (int j=0;j<280;j++) 
            { 
                file << "Peng!"; 
            }

dies:

for (int j=0;j<35;++j)
      file << "Peng!Peng!Peng!Peng!Peng!Peng!Peng!Peng!";

++x statt x++

Quatsch!
Für einfache Datentypen wird das wegoptimiert.

Der Wartende schrieb:

++x statt x++

Quatsch!
Für einfache Datentypen wird das wegoptimiert.

Mag ja sein, aber für Iteratoren u.U. nicht. Daher ist es durchaus sinnvoll, grundsätzlich nach Möglichkeit die Präfixversion zu verwenden.

@Stromberg: versuche es mal mit C-Dateistreams.

Ich denke mal der Flaschenhals hier wird wohl das Schreiben der Datei sein. Da hilft Metaprogrammierung nicht viel.

Der Haupt-Performance-Gewinn ist sicherlich zu erreichen, indem die Anzahl der Datei-Schreibzugriffe optimiert wird (aber die Streams haben doch interne Buffer dafür, oder?). Mit Metaprogrammierung kann man aber hier immerhin zumindest noch die beiden inneren Schleifen auflösen und den Dateiinhalt vom Compiler vorberechnen lassen.

Mit Metaprogrammierung kann man aber hier immerhin zumindest noch die beiden inneren Schleifen auflösen und den Dateiinhalt vom Compiler vorberechnen lassen.

Ich glaube, um eine Ausgabe von ca. 28 Millionen Zeichen vorzuberechnen, dürftest du deinen Compiler in die Knie zwingen Aber vermutlich könnte es schon etwas bringen, wenn man erst alle Ausgaben in einen String zusammenfasst und dann am Stück schreibt.

(noch schneller könnte es werden, wenn du die Datei einmal schreibst und 3999 mal mit System-Funktionen kopierst)

Braunstein schrieb:

Ich denke mal der Flaschenhals hier wird wohl das Schreiben der Datei sein. Da hilft Metaprogrammierung nicht viel.

Der Haupt-Performance-Gewinn ist sicherlich zu erreichen, indem die Anzahl der Datei-Schreibzugriffe optimiert wird (aber die Streams haben doch interne Buffer dafür, oder?). Mit Metaprogrammierung kann man aber hier immerhin zumindest noch die beiden inneren Schleifen auflösen und den Dateiinhalt vom Compiler vorberechnen lassen.

Ja, zeig bitte her wie das geht

#include <iostream>
#include <fstream>
#include <limits>
#include <string>
#include <sstream>
#include "ic.hpp"

#define PRINT "Peng! Peng! Peng! Peng! Peng! Peng! Peng! Peng! Peng! Peng! Peng! Peng! Peng! Peng!"

using namespace std;
using namespace ic::shorties;

int main()
{
    hide();
    string file_name;
    ofstream file;
    ostringstream temp;

    for(int l=0;l<4000;++l)
    {
        temp << l;
        file_name="D:/Peng"+temp.str()+".txt";
        file.open(file_name.c_str(),ios::out | ios::app);
        for (int i=0;i<20000;++i)
        {
            for (int j=0;j<20;++j)
            {
                file << PRINT;
            }
            file << "\n";
        }
        file.close();
    }

    return 0;
}

???

Und was mich noch bissel ankotzt, wenn ich das in meinem Compiler ausführe (MinGW) dann dauert das natürlich ewig, aber wenn ich dann auf "abort" [Code::blocks] klicke, dann kommt "be patience".....hallo? Für was gibts n dann den "abort" button?

Und wenn ich es im Compiler ausführe und für l z.B. nur "l<4" setze, dann bleibt es trotzdem hängen. Es funktioniert nur wenn ich die ".exe" direkt ausführe....

Dann noch, was ist den mit "Release Mode" gemeint? Irgendjemand hat da was von gesagt.

Ich probier jetzt dann mal noch das mit dem:

KasF schrieb:

Von den stringstreams auf normale char's umsteigen und dein PENG-Dinge schon vorher als Datenstruktur bauen und dann mit write die Datei schreiben ...

MfG
Stromberg

PS: Ich kann da doch mein Pc net mit kaputt machen oder? Was würde den passieren, wenn ich das jetzt auf C:\ mit "l<4000" durchlaufen lassen würde. Ich mein also, wenn C:\ voll ist, was passiert n dann, bricht Windows dann mein Programm automatisch ab.....what will happen?

CSpille schrieb:

Der Wartende schrieb:

++x statt x++

Quatsch!
Für einfache Datentypen wird das wegoptimiert.

Mag ja sein, aber für Iteratoren u.U. nicht. Daher ist es durchaus sinnvoll, grundsätzlich nach Möglichkeit die Präfixversion zu verwenden.

Im Code sind aber keine Iteratoren
Ich verwende auch grundsätzlich Preincreament.
Wie gesagt, für einfache Datentypen irrelevant, ob Preincreament oder nicht.
Außerdem sind Iteratoren ja keine einfachen Datentypen. Folglich sehe ich
keinen Fehler in meiner Aussage ^^

Im Code sind aber keine Iteratoren

Ach nein
Dennoch ist es, wie ich schrieb, sinnvoll, grundsätzlich die Präfix-Operatoren zu verwenden, wenn sie angebracht sind. Was kein Iterator ist, kann immer noch einer werden (diese Austauschbarkeit macht das Konzept ja so interessant), und auch um der Gewohnheit willen sollte man darauf achten.

Wie findet ihrs wenn ich das mit "define" machen würde

Furchtbar. '#define' ist hier vollkommen unangebracht. Wenn schon, dann definier eine reguläre Konstante.