Programmlaufzeitfrage

[Plotzenhotz]

p.S.: @volkard: ich wollte eigentlich auch nur die "0,6 Sekunden" von "Werner Salomon" etwas relativieren - er hat ja den Vergleich mit stdio nicht angestellt, diesen habe ich jetzt nachgeholt -- um zu zeigen dass seine 0,6 Sekunden bloss wenig klingen weil der OP anscheinend einen sehr langsamen PC hat

[Konrad Rudolph]

Plotzenhotz schrieb:

Wollen wir wetten dass iostream trotzdem langsamer bleibt als stdio?

Klar. Es handelt sich ja auch um eine extrem dynamische Bibliothek, die objektorientiert implementiert ist, mit dem gesamten damit verbundenen Overhead (virtuelle Funktionen).

Als Resultat erhält man ein ungemein mächtiges und nützliches Werkzeug, das quasi beliebig erweitert werden kann. Das mit stdio zu vergleichen ist in jedem Fall unsinnig.

[Helmut S.]

Meine Ergebnisse:
Jeweils 100000 Zeilen a 25 Zeichen lesen und jede zweite Zeile in neue Datei schreiben.
(VC++ 8.0 release-build Pentium 4)

#include <iostream>
#include <fstream> 
#include <string> 
#include <time.h> 
#include <conio.h> 

using namespace std; 

int main () 
{   // VARIANTE 1 C++
    clock_t start=0, finish=0; 
    string text,text2, muell; 

    start = clock();  

    ifstream indatei("c:\\EINLAUF.TXT");  
    ofstream outdatei("c:\\EINLAUFXXX.TXT"); 

    if(indatei) 
        while(getline(indatei, text2)) 
        { 
                text += text2;
                text += "\n";
                getline(indatei,muell); 
        } 

    outdatei << text; 

    finish = clock();     
    indatei.close();
    outdatei.close();
    cout  << "VARIANTE 1 C++ " << endl
     << "Rechenzeit C++ -Code : " << (double)(finish - start) << " ms" << endl << endl; 

//*****************************************************************        

#define IN_DATEI "c:\\EINLAUF.TXT" 
#define OUT_DATEI "c:\\EINLAUFXXX.TXT" 
#define N 25            // Vektorlänge der Char-Felder 
#define ABBR 1000000    // max. Schleifenlänge für Not-Abbruch 

    FILE *fptr1; 
    FILE *fptr2; 
    unsigned long is = 0; 
    char input[N], dummy[N]; 
    start=0, finish=0; 

    fptr1 = fopen(IN_DATEI, "r");    // Datei mit Werten 
    fptr2 = fopen(OUT_DATEI, "w");    // Ergebnisdatei mit halbierter Auflösung 

    if (!fptr1) 
        printf("Fehler beim Oeffnen der Input-Datei!\n"); 
    else 
    { 
        start = clock();    // 1. Wert für Rechenzeitbestimmung 

        while (fgets(dummy,    N, fptr1) != NULL)    // jedes Wertepaar mit ungeradem Index wird ignoriert 
        { 
            fgets(input, N, fptr1);    // jedes Wertepaar mit geradem Index wird gespeichert 
            fprintf(fptr2, "%s", input); 
            is++;    
            if (is>=ABBR) 
                break;    // Notausstieg aus while-Schleife bei einer best. max. Zeilenzahl 
        } 

        finish = clock();    // 2. Wert für Rechenzeitbestimmung 
        _fcloseall();     
        printf ("VARIANTE 2 C-Code\n");
        printf("Anzahl der Wertepaare vorher: %lu\n", is*2); 
        printf("Anzahl der Wertepaare jetzt: %lu\n", is); 
        printf("Rechenzeit C-Code : %.0f ms\n\n", (double)(finish - start)); 
        //printf("CPS:  %f\n\n", (float)CLOCKS_PER_SEC); 
    } 
//*******************************************************************************
//Letzer Versuch C++
    start = clock();
    ofstream aus;
    aus.open("c:\\EINLAUFXXX.TXT", ios_base::out | ios_base::binary| ios_base::trunc);
    ifstream ein;
    ein.open("c:\\EINLAUF.TXT", ios_base::in | ios_base::binary| ios_base::ate);
    char* zBuf;
    int len = ein.tellg();
    if (zBuf = new char [len])
    {
      ein.seekg(ios::beg);
      ein.read(zBuf, len);
    }
    else return -1;

    char* p = zBuf, *p2, *p3;
    size_t a, s = 0;
    int i = 0;
    for (int toggle = 0 ; i < len; ++i)
    {
        if (zBuf[i] == 10)
        {
            toggle ^= 1;        
            if (toggle)
            {
                p2 = &zBuf[i+1];         
                continue;
            }
            else
            {
                p3 = &zBuf[i+1];     
                a = p3-p2;
                memcpy(p, p2, a);
                p += a, s += a;
            }
        }
    }
    if (zBuf[i] != 10)
    {
        p3 = &zBuf[i], a = p3-p2;
        memcpy(p, p2, a);
        p += a, s += a;
    }
    aus.write(zBuf, (streamsize)s);

    finish = clock();
    cout    << "VARIANTE 3 C++ ohne std::string" << endl
            << "Rechenzeit C/C++ Code : " << (double)(finish - start) << " ms" << endl << endl; 
    ein.close();
    aus.close();
    delete[] zBuf;
    return 0;
}

Ausgabe:

VARIANTE 1 C++
Rechenzeit C++ -Code : 203 ms

VARIANTE 2 C-Code
Anzahl der Wertepaare vorher: 100000
Anzahl der Wertepaare jetzt: 50000
Rechenzeit C-Code : 109 ms

VARIANTE 3 C++ ohne std::string
Rechenzeit C/C++ Code : 31 ms

[Plotzenhotz]

So. Ich hab den Test mit "in.getline(buffer, sizeof(buffer))" gemacht (also ganz ohne std::string - womit wir nun endlich genau die selbe Funktionalität verglichen hätten), der ist nun statt Faktor 8.3 etwa Faktor 7.5 langsamer.

BTW: dass die "ios_base::binary und alles auf einmal lesen" Variante schnell ist ist klar, die verwendet ja auch die iostreams Library für nix anderes als einen grossen Block Daten zu kopieren. Das bringt man mit stdio genauso hin, und sicher auch wieder schneller, wenn auch wahrscheinlich bloss um ein paar Takte.

@Konrad Rudolph: ich hab auch von Anfang an behauptet dass iostreams langsamer sein wird als stdio (lies ein paar Postings weiter oben). Bloss kam dann so ein "dafür gibt es garkeinen Grund" Kommentar. Ob es einen Grund gibt hin oder her, auf jeden Fall ist es so, und ich sah mich genötigt das zu demonstrieren.

[volkard]

Plotzenhotz schrieb:

So. Ich hab den Test mit "in.getline(buffer, sizeof(buffer))" gemacht (also ganz ohne std::string - womit wir nun endlich genau die selbe Funktionalität verglichen hätten), der ist nun statt Faktor 8.3 etwa Faktor 7.5 langsamer.

das ist immernoch unfug.
zeig mal dein endgültiges programm, das unter fairen bedingungen <cstdio> mit <fstream> vergleicht und faktor 7.5 schneller ist. ich gebe mir ausnahmsweise die mühe, es zu verreißen, da du mir in anderen threads deutlich als ahnunghaber und hilfsbereiter aufgefallen bist.

[RHBaum]

Das ganze vergleichen hier ist doch Bullshit Leute !
Und auch noch Faktoren rausgeben wollen, was die clib schneller ist wie eine IOStream impl?

Jeder der mit streams arbeitet, weiss das er es ned wegen der geschwindigkeit tut. Wenn man sagt das c++ performant sein kann/soll, meint man in c++ auch so programmieren kann, das die geringfuegig geringere performance kein Grund sein soll die anderen vorteile von c++, der stl und dem stream konzept ueber boartd zu werfen !

Und wenn ich wirklich auf speed aus bin bei dateioperationen ( Bitte welchem vernunftigen Programmierer intressiert nen minimaler performanceverlust bei dateioperationen auf nem multhithreading/multiprocessing BS ??? ) aus bin, werd ich doch zuerst mein BS konsultieren (Posix, winapi) und die streams / filebuffer bei seite legen ...

Ciao ...

[volkard]

ich lass jetzt mal das hier dorchlaufen:

#include <iostream>
#include <cstdio>
#include <fstream>
#include <string>
using namespace std;

#define g_inputFileName "test.txt"
#define gc_lineCount 100000000

void CreateTestFile()
{
    FILE* outFile = fopen(g_inputFileName, "w");
    if(!outFile)
        abort();

    for(size_t i = 0; i < gc_lineCount; i++)
    {
        int r = rand() % 3;
        char const* s = 0;
        switch(r)
        {
        case 0: s = "Bla, Bloe\n"; break;
        case 1: s = "Ding, Dong\n"; break;
        case 2: s = "X, Y\n"; break;
        }

        fputs(s, outFile);
    }

    fclose(outFile);
}

int countLineNumbers1(){
	int result=0;
	FILE* inFile = fopen(g_inputFileName, "r");
	if(!inFile)
		abort();
	char buffer[1024];
	while(fgets(buffer, sizeof(buffer), inFile))
		++result;
	fclose(inFile);
	return result;
}

int countLineNumbers2(){
	int result=0;
	ifstream inFile(g_inputFileName);//edit: hier war fehlerhaft ios::binary
	if(!inFile)
		throw 4711;
	char buffer[1024];
	while(inFile.getline(buffer,1024))
		++result;
	return result;
}

int countLineNumbers3(){
	int result=0;
	ifstream inFile(g_inputFileName,ios::binary);
	if(!inFile)
		throw 4711;
	string buffer;
	while(getline(inFile,buffer))
		++result;
	return result;
}

int main()
{
	CreateTestFile();
	for(int i=0;i<10;++i)
	{
		{
			clock_t start=clock();
			cout<<1<<' '<<countLineNumbers1()<<' ';
			cout<<(clock()-start)/double(CLOCKS_PER_SEC)<<endl;
		}
		{
			clock_t start=clock();
			cout<<2<<' '<<countLineNumbers2()<<' ';
			cout<<(clock()-start)/double(CLOCKS_PER_SEC)<<endl;
		}
		{
			clock_t start=clock();
			cout<<3<<' '<<countLineNumbers3()<<' ';
			cout<<(clock()-start)/double(CLOCKS_PER_SEC)<<endl;
		}
	}
	return 0;
}

das zählt einfach nur die zeilen einer ca 1G großen (einstellbar) datei.

ausgabe:

1 100000000 19.906
2 100000000 19.734
3 100000000 36.516
1 100000000 19.765
2 100000000 19.735
3 100000000 36.703
1 100000000 19.75
2 100000000 19.875
3 100000000 36.469
1 100000000 19.75
2 100000000 19.968
3 100000000 36.313
1 100000000 19.859
2 100000000 19.672
3 100000000 36.188

ich denke mal, an dem ergebnis gibts wenig zu interpretieren. string ist lahm. fstream und iostream sind gleich schnell.

[HumeSikkins]

@volkard
Welchen Compiler bzw. welche Standard-Lib verwendest du? Erhalte mit dem VC 8 andere Ergebnisse:

1 10000000 1.922
2 10000000 5.734
3 10000000 7.891
1 10000000 1.906
2 10000000 5.687
3 10000000 7.891
[...]

Dateigröße war ca. 100 MB.

[volkard]

Plotzenhotz schrieb:

So. Ich hab den Test mit "in.getline(buffer, sizeof(buffer))" gemacht (also ganz ohne std::string - womit wir nun endlich genau die selbe Funktionalität verglichen hätten), der ist nun statt Faktor 8.3 etwa Faktor 7.5 langsamer.

die selbe funktionalität reicht aber nicht. wenn man wie Helmut S. die c-variante einigermaßen annehmbar implementiert aber die c++-variante wie der letzte gamecoder vergurkt, ist der vergleich nicht fair.

ich hab auch nicht gerafft, warum man für

//so oder so ähnlich war's doch
while(in.getline(file,buffer))&&in.getline(file,buffer))
   out.write(buffer);

ein mords brimboriom (unübersichtlich, unnötig, lahm) mit ner klasse namens doppelzeile machen muss.

[volkard]

HumeSikkins schrieb:

@volkard
Welchen Compiler bzw. welche Standard-Lib verwendest du? Erhalte mit dem VC 8 andere Ergebnisse:

MinGW

D:\source\filetest>g++ -v
Reading specs from C:/MinGW/bin/../lib/gcc/mingw32/3.4.2/specs
Configured with: ../gcc/configure --with-gcc --with-gnu-ld --with-gnu-as --host=
mingw32 --target=mingw32 --prefix=/mingw --enable-threads --disable-nls --enable
-languages=c,c++,f77,ada,objc,java --disable-win32-registry --disable-shared --e
nable-sjlj-exceptions --enable-libgcj --disable-java-awt --without-x --enable-ja
va-gc=boehm --disable-libgcj-debug --enable-interpreter --enable-hash-synchroniz
ation --enable-libstdcxx-debug
Thread model: win32
gcc version 3.4.2 (mingw-special)

1 10000000 1.922
2 10000000 5.734
3 10000000 7.891
1 10000000 1.906
2 10000000 5.687
3 10000000 7.891
[...]

Dateigröße war ca. 100 MB.

jo, dann ist die ms-lib wiedermal buggy.
hab jetzt auch mit ms gemessen.

1 100000000 25.219
2 100000000 52.703
3 100000000 67.984

[HumeSikkins]

Hat noch jemand einen älteren VC installiert? Mich würde mal interessieren, wie die nicht-standard-IOStreams abschneiden. Also <iostream.h> und <fstream.h> statt
<iostream> und <fstream>.

[Plotzenhotz]

das ist immernoch unfug.
zeig mal dein endgültiges programm, das unter fairen bedingungen <cstdio> mit <fstream> vergleicht und faktor 7.5 schneller ist. ich gebe mir ausnahmsweise die mühe, es zu verreißen, da du mir in anderen threads deutlich als ahnunghaber und hilfsbereiter aufgefallen bist.

Mein endgültiges Programm zeig ich heut' Abend her, sitz grad noch in der Arbeit. Ich bitte nur meine Postings in diesem Thread im Kontext zu sehen, die "Doppelzeile" Sache z.B. stammt nicht von mir, hab ich nur übernommen um zu zeigen dass die auch nicht schneller ist als die "einfache" (normale) Variante. Da ich mich mit iostreams noch nicht SO angefreundet habe wusste ich auch schlichtweg nicht dass getline() mit char* Buffer verfügbar ist, daher hab ich nen std::string genommen. Egal. Meine Erfahrung ist dass iostreams deutlich langsamer sind, so ziemlich egal was man macht. Mag daran liegen dass die MSVC Variante mies implementiert ist. Wie gesagt später mehr.

Und eine Frage gleich vorweg: wie bitte ist "ios::binary" mit fopen(..., "r") zu vergleichen fair? Wenn dann bitte "ios::binary" mit fopen(..., "rb") vergleichen, sonst brauchen wir über fair gleich garnicht zu sprechen. Dass es auf UNIX systemen keinen Unterschied macht ist mir dabei egal, bei MSVC z.B. macht es einen Unterschied. Da es hier aber um Textfiles geht denke ich sollten wir beim "r" und ohne "ios::binary" bleiben. Auf jeden Fall entweder beide binary oder beide als Text Stream.

[volkard]

Plotzenhotz schrieb:

Und eine Frage gleich vorweg: wie bitte ist "ios::binary" mit fopen(..., "r") zu vergleichen fair?

ups, das war noch aus versehen drin. hab allerlei verstellt und probiert, um rauszufinden, wie ihr auf die lahmen ergebnisse kommt. ios::binary gehört da nicht rein und macht aber auch keinen unterschied, hoffe ich.

edit: doch, macht anscheinend deutlichen unterschied. muss ich heut abend ausmessen.

[Plotzenhotz]

@volkard:
So. Forum geht wieder (was warn da los?). Gut.
Hab mich nu noch etwas rumgespielt und ein paar kleine Fallstricke für die iostreams entfernt. u.a. das "std::endl" durch '\n' ersetzt und zurück zu MSVC 7.1 da die meiste Zeit bei der MSVC 8 Version beim locking/unlocking diverser critical sections draufgegangen ist (mehrmals pro "getline" Aufruf - daher auch die wüst groben Unterschiede zur stdio Version). Und MSVC 8 hat leider keine single threaded runtime mehr. Neuer Code:

#define _WIN32_WINNT 0x0501

#include <windows.h>
#include <mmsystem.h>
#undef min
#undef max

#include <stdlib.h>
#include <stdio.h>
#include <conio.h>
#include <time.h>
#include <iostream> 
#include <fstream>

#pragma comment(lib, "winmm")

static const char* const gc_inputFileName = "c:\\in.txt";
static const char* const gc_outputFileName = "c:\\out.txt";
static const size_t gc_lineCount = 160*1000;

void CreateTestFile()
{
	FILE* outFile = fopen(gc_inputFileName, "w");
	if(!outFile)
		abort();

	for(size_t i = 0; i < gc_lineCount; i++)
		fputs("123456789012345678901234\n", outFile);

	fclose(outFile);
}

void ReadInputFileStdio()
{
	FILE* inFile = fopen(gc_inputFileName, "r");
	if(!inFile)
		abort();

	char buffer[1024];
	while(fgets(buffer, sizeof(buffer), inFile))
		;

	fclose(inFile);
}

void ReadInputFileIostream()
{
	std::ifstream in(gc_inputFileName);
	char buffer[1024];
	while(in.good())
		in.getline(buffer, sizeof(buffer));
}

size_t TestStdio()
{
	FILE* inFile = fopen(gc_inputFileName, "r");
	if(!inFile)
		abort();

	FILE* outFile = fopen(gc_outputFileName, "w");
	if(!outFile)
		abort();

	size_t outLines = 0;

	char buffer[1024];
	while(1)
	{
		if(!fgets(buffer, sizeof(buffer), inFile))
			break;
		if(!fgets(buffer, sizeof(buffer), inFile))
			break;

		if(fputs(buffer, outFile) < 0)
			abort();

		outLines++;
	}

	fclose(inFile);
	fclose(outFile);

	return outLines;
}

size_t TestIostream3() 
{ 
	std::ifstream in(gc_inputFileName);
	std::ofstream out(gc_outputFileName);

	char buffer[1024];

	size_t outLines = 0;

	while(1)
	{
		if(!in.getline(buffer, sizeof(buffer)))
			break;
		if(!in.getline(buffer, sizeof(buffer)))
			break;

		out << buffer << '\n';
		outLines++;
	}

	return outLines;
}

int main(int argc, char** argv)
{
	CreateTestFile();

	if(::timeBeginPeriod(1) != TIMERR_NOERROR)
		abort();

	size_t outLineCount = 0;
	DWORD t0, t1;

	// TestStdio
	for(unsigned rep = 0; rep < 5; rep++)
	{
		::DeleteFileA(gc_outputFileName);
		ReadInputFileStdio();
		ReadInputFileStdio();
		printf("TestStdio: ");
		t0 = ::timeGetTime();
		outLineCount = TestStdio();
		t1 = ::timeGetTime();
		printf("Lines: %ld, time: %ld msec\n", long(outLineCount), long(t1 - t0));
	}

	// TestIostream3
	for(unsigned rep = 0; rep < 5; rep++)
	{
		::DeleteFileA(gc_outputFileName);
		ReadInputFileIostream();
		ReadInputFileIostream();
		printf("TestIostream3: ");
		t0 = ::timeGetTime();
		outLineCount = TestIostream3();
		t1 = ::timeGetTime();
		printf("Lines: %ld, time: %ld msec\n", long(outLineCount), long(t1 - t0));
	}

	::timeEndPeriod(1);

	printf("\nPress any key to continue.\n");
	getch();
}

Ergebnis (Pentium 4 Northwood, 2.8GHz, XP SP2):

TestStdio: Lines: 80000, time: 66 msec
TestStdio: Lines: 80000, time: 66 msec
TestStdio: Lines: 80000, time: 66 msec
TestStdio: Lines: 80000, time: 66 msec
TestStdio: Lines: 80000, time: 67 msec
TestIostream3: Lines: 80000, time: 111 msec
TestIostream3: Lines: 80000, time: 105 msec
TestIostream3: Lines: 80000, time: 107 msec
TestIostream3: Lines: 80000, time: 108 msec
TestIostream3: Lines: 80000, time: 112 msec

Press any key to continue.

Nu ham wir 66 vs. 105 msec.
Ohne output:

TestStdio: Lines: 80000, time: 34 msec
TestStdio: Lines: 80000, time: 32 msec
TestStdio: Lines: 80000, time: 33 msec
TestStdio: Lines: 80000, time: 32 msec
TestStdio: Lines: 80000, time: 45 msec
TestIostream3: Lines: 80000, time: 71 msec
TestIostream3: Lines: 80000, time: 70 msec
TestIostream3: Lines: 80000, time: 69 msec
TestIostream3: Lines: 80000, time: 69 msec
TestIostream3: Lines: 80000, time: 90 msec

Press any key to continue.

Also 32 vs. 69 msec. Viel besser als mit MSVC 8, aber iostreams immer noch langsamer. Falls ich da jetzt immer noch nen "Fehler" (eine "Bremse") in der iostream Implementierung drin habe bitte gerne mich darauf hinzuweisen.

"Selber Code" mit MSVC6, <iostream.h> und <fstream.h> (std:: entfernt, die liegen beim MSVC 6 im global namespace, und "rep" vor den Schleifen definiert, weil MSVC 6 for-scope-bug, sonst keine Änderung). Optimiert für Pentium-Pro, inlining aktiviert, single-threaded Runtime, ... . R/W:

TestStdio: Lines: 80000, time: 72 msec
TestStdio: Lines: 80000, time: 70 msec
TestStdio: Lines: 80000, time: 68 msec
TestStdio: Lines: 80000, time: 69 msec
TestStdio: Lines: 80000, time: 69 msec
TestIostream4: Lines: 80000, time: 191 msec
TestIostream4: Lines: 80000, time: 174 msec
TestIostream4: Lines: 80000, time: 184 msec
TestIostream4: Lines: 80000, time: 172 msec
TestIostream4: Lines: 80000, time: 175 msec

Press any key to continue.

R:

TestStdio: Lines: 80000, time: 34 msec
TestStdio: Lines: 80000, time: 34 msec
TestStdio: Lines: 80000, time: 34 msec
TestStdio: Lines: 80000, time: 32 msec
TestStdio: Lines: 80000, time: 32 msec
TestIostream4: Lines: 80000, time: 126 msec
TestIostream4: Lines: 80000, time: 202 msec
TestIostream4: Lines: 80000, time: 128 msec
TestIostream4: Lines: 80000, time: 124 msec
TestIostream4: Lines: 80000, time: 123 msec

Press any key to continue.

Andere Compiler hab ich leider keine, STLPORT auch nicht, wäre aber interessant wie schnell die ist.
Und... hast du mit oder ohne MT Support compiliert? Würe mich nur interessieren.

[volkard]

Plotzenhotz schrieb:

Und... hast du mit oder ohne MT Support compiliert? Würe mich nur interessieren.

ohne MT.
ich habe ca. 30% overhead für das verwenden von ifstream. da muß ich wohl doch nach c umsteigen.

[Plotzenhotz]

Eiei, wieder ein spitzes Kommentar Mir ist es im Prinzip wurscht ob irgendwo irgendetwas langsamer/schneller ist. Mich nervt nur wenn jmd. sowas wie die iostream vs. stdio hernimmt (oder wie gerade eben std::vector vs. malloc+memset) und sich dann wundert dass es langsamer ist. Klar kanns langsamer sein, macht ja nixe. Genauso nervt es mich aber auch wenn dann jmd. hergeht und behauptet es gäbe garkeinen Grund dass A langsamer als B ist. Kann schon sein dass es keinen guten Grund gibt dass es so sein muss, aber wenns so ist, dann muss man sich einfach damit abfinden. Wenns wichtig ist wo das letzte bisschen an Geschwindigkeit rauszuholen dann schreib' ich das sowieso mit Hand bzw. mache zumindest Tests mit den verschiedensten Sachen. Und wenns nicht wichtig ist nimmt man einfach das was am einfachsten zu schreiben und verstehen ist und fertig.

[volkard]

Plotzenhotz schrieb:

Genauso nervt es mich aber auch wenn dann jmd. hergeht und behauptet es gäbe garkeinen Grund dass A langsamer als B ist.

ich sage aber weiterhin: es gibt gar keine notwendigkeit, daß iostream lahmer als stdio ist.
darüberhinaus möchte ich behaupten, daß da anscheinend auf breiter front gepfuscht wird. bei MS kann ich mir ja noch denken, daß es nur drum geht, VB unbd C# schneller aussehen zu lassen. bei gcc weiß ich's nicht. vielleicht sind die vorgaben im standard ja schon so, daß es dafür keine schnelle implementierung geben kann, ohne daß die exe-datei noch 200k größer wird.

[Plotzenhotz]

Ja vielleicht hab ich mich in diesem Thread auch nicht richtig ausgedrückt. Mir ging es alleine um die Feststellung dass die derzeitigen iostreams Implementierungen die ich kenne, und von denen ich diverse Benchmarks im Netz gelesen habe, alle langsamer sind als stdio.
Zu behaupten dass es immer so sein muss war ein Fehler - das kann ich nicht beurteilen ohne den Standard wesentlich besser zu kennen als ich es tue.

[volkard]

Plotzenhotz schrieb:

Mir ging es alleine um die Feststellung dass die derzeitigen iostreams Implementierungen die ich kenne, und von denen ich diverse Benchmarks im Netz gelesen habe, alle langsamer sind als stdio.

ok.
mir war bekannt, daß cout derzeit überall lahmer ist als printf, obwohl es technische gründe gibt, weshalb cout schneller sein sollte.
jetzt ist mir dank dieses threads zusätzlich bekannt, daß zeilenlesen mit ifstream deutlich lahmer ist als mit FILE*, obwohl es dafür gar keinen technischen grund gibt.
vermutlich hat gar nicht bjarne s. diese sprache erfunden. das war noch mitten im kalten krieg. die russen haben sie erfunden, um die westliche entwicklung der computerwissenschaften lahmzulegen. also sie ist schonmal so kompliziert, daß man selbst als vollprofi libs schreibt, die lahm sind und 10 jahr später noch keiner schnelle libs gebaut hat (im gegenteil, so lahm wie bei ms heute waren sie nie, vermute ich). vielleicht ist nichtmal c++ allein dfas problem, sondern die ganze objektorientierung. java ist ja auch nicht berühmt für schnelle dateifilteroperationen. ich werde das mal beobachten und bei gelegenheit kaufe ich mir in ebay einen 64-er. kann ja sein, daß die entwicklung so weitergeht und ich dann mit dem 64-er schneller bin.

[Spacelord]

Plotzenhotz schrieb:

Ja vielleicht hab ich mich in diesem Thread auch nicht richtig ausgedrückt. Mir ging es alleine um die Feststellung dass die derzeitigen iostreams Implementierungen die ich kenne, und von denen ich diverse Benchmarks im Netz gelesen habe, alle langsamer sind als stdio.
Zu behaupten dass es immer so sein muss war ein Fehler - das kann ich nicht beurteilen ohne den Standard wesentlich besser zu kennen als ich es tue.

Wenn du da nen halbwegs fairen Vergleich machen willst musst du direkt mit dem streambuf der Streamklassen arbeiten.
So ist z.B. das gleichwertige C++ Gegenstück zu getc nicht istream::get sondern streambuf::sbumpc.
Die Streamklassen kapseln den Streambuffer und sind vollgestopft mit Status und Fehlercode.Das ist imho zusätzlicher Overhead den die mit sich rum schleppen.

Gruß Spacelord