Warum funktioniert diese Version perfekt (im oberen Beispiel könnte auch double stehen wenn fmod dekommentiert ist)

und diese hier spuckt etwas komplett falsches aus?

int main()
{
	double i, j;
	int test = 1;
	double erg;
	double fm;

	for (i = 1;; i++)
	{
		for (j = 1; j <= 20; j++)
		{
			fm = fmod(i, j);
			if (fm)
			{
				test=0;
				break;
			}
		}
		if (test == 1)
		{
			cout << i <<endl;
			return 0;
		}
		test = 1;
		//printf("%d\n",i);
	}
}

Edit v. Arcoth: Code in lesbare Formen umgeführt

Aber eigentlich wollte ich wissen warum cout so heftig auf das double reagiert

Tausende vorbei ist das jetz nicht.

Eine andere Zahl als die richtige
Ganz normale Zahl, ungefähr ein paar tausend von der richtigen entfernt, beide im 200 Millionen Bereich. Weiß sie aber nicht mehr auswendig.

Aber eigentlich wollte ich wissen warum cout so heftig auf das double reagiert

In beiden Fällen wird die gleiche Zahl ausgegeben. Nur bei cout auf 6 Stellen gerundet, da Du bei cout keine weiteren Angaben für die Formatierung gemacht hast. Default ist 6.

Bei mir
cout bei double 2.32793e+08
cout bei double mit cout.setf(cout.scientific) 2.327926e+08
printf bei double 232792560.000000
cout/printf bei long long 232792560

Tausende vorbei ist das jetz nicht.

Ist doch alles korrekt?

ja, warum wird hier gerundet?
sorry, bemerk das jetzt erst wo ich die zahlen nebeneinander sehe

Kenner der Ausgabe schrieb:

In beiden Fällen wird die gleiche Zahl ausgegeben. Nur bei cout auf 6 Stellen gerundet, da Du bei cout keine weiteren Angaben für die Formatierung gemacht hast. Default ist 6.

Und das ist übrigens bei printf und bei den C++-Streams exakt gleich.

#include <iostream>
#include <limits>   // numeric_limits

// --   ggt & kgV
int ggT( int a, int b ) // größter gemeinsamer Teiler
{
    return a == 0? b: ggT( b%a, a ); 
}

int kgV( int a, int b ) // kleinstes gemeinsames Vielfaches
{
    const int gt = ggT( a, b );
    return (a/gt) * b;
}

// ... und schon wird es einfach und schnell 
int main() {
    using namespace std;
    int ergebnis = 1;
    for( int i = 1; i <= 20; ++i )
        ergebnis = kgV( i, ergebnis );
    cout.precision( numeric_limits<int>::digits10 ); // damit auch alle Ziffern in der Ausgabe erscheinen
    cout << ergebnis << endl;
}

ja, warum wird hier gerundet?
sorry, bemerk das jetzt erst wo ich die zahlen nebeneinander sehe

Wieviel Stellen soll es denn standardmäßig ausgeben? Eine? Hundert? Nee, der Standard sieht 6 vor und wenn du die Ausgabe genauer haben willst, musst du das selbst angeben. Du kannst die Zahl sogar mit nur einer Nachkommastelle ausgeben, dann wird auch gerundet.

#include <iostream>
#include <iomanip>
#include <cmath>
#include <limits>
int main()
{
    const long double pi = std::acos(-1.L);
    std::cout << "default precision (6): " << pi << '\n'
              << "std::precision(10):    " << std::setprecision(10) << pi << '\n'
              << "max precision:         "
              << std::setprecision(std::numeric_limits<long double>::digits10)
              << pi << '\n';
}

Oder so ähnlich. Ausgabe:

default precision (6): 3.14159
std::precision(10):    3.141592654
max precision:         3.14159265358979324

Auch interessant: std::fixed , std::scientific , std::hexfloat , std::defaultfloat
Siehe auch:
http://en.cppreference.com/w/cpp/io/manip/fixed

3.1415926535897932384626433832795028841971693993751  // Pi, mathematisch, 50 Stellen
3.1415926535897932385128089594061862044327426701784  // Pi aus Programm, 50 Stellen
3.14159265358979324                                  // Pi aus Programm, "max_precision" Stellen
3.14159265358979323851                               // Pi aus Programm, max_digits10 Stellen

Pi aus Programm, 50 Stellen

2*std::asin(1.L) ?

Pi aus Programm, 50 Stellen

2*std::asin(1.L) ?

Nein, das, was oenone geschrieben hat, übernommen. Also std::acos(-1.L);