Ein C-Programm und ich habe keine Ahnung...

[Crash2001]

Geht das bei einer FOR-Schleife überhaupt, dass die Inkrementierung nicht im Kopf sondern unten drunter gemacht wird? :confused: So habe ich das noch nie gesehen. Genauso wie man kein kleinergleich braucht, sondern ein kleiner ausreicht, da kleiner vor gleich kommt, wenn man etwas dazuaddiert und daher die Bedingung zum Ende der Schleife damit früher erreicht wird.

Ich kenne das so:

for(int x = 0; x < 100; x+=2){

//was zu machen ist;

}

Ach ja, Schrittweite war 3 und nicht 2.

[Klotzkopp]

Geht das bei einer FOR-Schleife überhaupt, dass die Inkrementierung nicht im Kopf sondern unten drunter gemacht wird?

Kann man machen, ist aber ungewöhnlich. Man muss dann auch beachten, dass im Falle eines continue dann eben nichts passiert.

Das zweite Semikolon muss aber in die for-Anweisung rein.

Genauso wie man kein kleinergleich braucht, sondern ein kleiner ausreicht, da kleiner vor gleich kommt, wenn man etwas dazuaddiert und daher die Bedingung zum Ende der Schleife damit früher erreicht wird.

Man kann beides benutzen, muss dann nur eben den Wert entsprechend anpassen. 100 ist hier mit beidem falsch

[absoluteranfänger]

Hier überschlagen sich ja die Antworten!

Ist ja echt ein super Forum hier

Ich habe die ganze Zeit über folgenden Code "entwickelt":

#include <stdio.h>


int main (void)

{

	int a;

	double ergebnis;

	for ( a = 2; a <= 200; a = a + 2)

	{

		ergebnis = (1 / (a) * (a+1) * (a+2));

	}

	printf ("Ergebnis: %f\n", ergebnis);

	return 0;

}

Allerdings bekomme ich als Ergebisausgabe bis jetzt leider immer 0.00.

Ich habe den Fehler noch nicht gefunden, wollte aber nun erst einmal was Essen Vielleicht könnt ihr mir ja noch einen Hinweis auf den Fehler geben.

Bearbeitet 3. September 2008 von Klotzkopp
Code-Tags hinzugefügt

[TDM]

ergebnis = (1 / (a) * (a+1) * (a+2));

oder:

ergebnis += (1 / (a) * (a+1) * (a+2));

?

:floet:

[Editerle]

double wird mit %lf ausgegeben.

[Hexagon]

Zwischenruf aus der zweiten Reihe:

1. Wieso int und double mischen?
2. Beim rechnen mit int kommt für sehr kleine Zahlen immer 0 raus.
3. Zuweisung != Aufsummierung
   

[Klotzkopp]

double wird mit %lf ausgegeben.

Nö. :floet:

%lf gibt's bei printf nicht. Bei scanf hättest du Recht.

[TDM]

%lf gibt's bei printf nicht.

Nicht?

Week 3: printf, scanf

Da steht das aber mit %lf. :beagolisc

außerdem ist doch %f für float und wenn double aber den Wertebereich von float überschreitet, dann gibts komische ergebnisse.

[Klotzkopp]

Da steht das aber mit %lf. :beagolisc

Ja, im Web gibt's leider manches, was falsch (oder zumindest unnötig) ist. Du findest bestimmt auch etliche Stellen, an denen das mit %d gemacht wird

Ich könnte mir vorstellen, dass eine fehlertolerante printf-Implementierung das l einfach ignoriert.

außerdem ist doch %f für float

Laut Standard werden float-Funktionsargumente sowieso in double umgewandelt, wenn kein Prototyp vorliegt, oder (wie bei printf) eine Ellipse. Eine Unterscheidung ist also bei printf ohnehin Unsinn, denn dort kommen niemals floats an. Bei scanf ist das natürlich anders, es gibt keine automatische Konvertierung von float* in double*.

und wenn double aber den Wertebereich von float überschreitet, dann gibts komische ergebnisse.

Wie soll das denn hier passieren? Float wird in double umgewandelt, nicht umgekehrt.

[absoluteranfänger]

So, nun habe ich den Programmcode also nochmal nach euren Hinweisen (soweit ich sie eben halt verfolgen konnte) überarbeitet:

#include <stdio.h>

int main (void)

{

int a;

double ergebnis;

for ( a = 2; a <= 200; a = a + 2)

{

ergebnis += (1 / (a) * (a+1) * (a+2));

}

printf ("Ergebnis: %f\n", ergebnis);

return 0;

}

Ich bekomme auch ein Ergebnis, leider hat mir das aber zu viele Stellen. Ich habe mal ein Screenshot vom Ergebnis gemacht:

Kann ich das durch irgendeinen Befehl noch anschaulicher gestalten?

[TDM]

Ich bekomme auch ein Ergebnis, leider hat mir das aber zu viele Stellen.

Fällt dir da nicht auf, dass es trotz einer Addition mit positiven Werten zu einem negativen Ergebnis kommt?!

Initialisier mal ergebnis mit:

double ergebnis = 0.0;

Laut Standard werden float-Funktionsargumente sowieso in double umgewandelt, wenn kein Prototyp vorliegt

Man lernt nie aus. :beagolisc

Wie soll das denn hier passieren? Float wird in double umgewandelt, nicht umgekehrt.

S.o.; wusst ich nicht.

[absoluteranfänger]

Fällt dir da nicht auf, dass es trotz einer Addition mit positiven Werten zu einem negativen Ergebnis kommt?!

Initialisier mal ergebnis mit:

double ergebnis = 0.0;

Ist mir aufgefallen, aber ich bekomm das nicht anders hin!

Dein Vorschlag führt im übrigen zu folgendem Ergebnis:

[TDM]

Dein Vorschlag führt im übrigen zu folgendem Ergebnis

Jo, das ist die Sache die Hexagon meinte:

1/int*int*int wäre eigentlich 0.xxxx aber bei int gibts keine Nachkommastellen also wird immer auf 0 abgerundet, folglich wird zu dem Ergebnis immer nur 0 hinzugezählt.

	double ergebnis = 0.0;

	for ( double a = 2.0; a <= 200; a += 2.0)

	{

	ergebnis += (1 / (a) * (a+1) * (a+2));

	}

	printf ("Ergebnis: %f\n", ergebnis);

[Klotzkopp]

Alternativ kann man a als int belassen, und das so schreiben:

ergebnis += (1[B].0[/B] / (a) * (a+1) * (a+2));

Dadurch, dass nun einer der Operanden vom Typ double ist - nämlich das Literal 1.0 - wird hier eine Fließkommadivision ausgeführt. Da passt das Ergebnis dann auch rein.

So ist die Formel übrigens noch falsch. Es bringt nichts, den gesamten Ausdruck in Klammern zu setzen, denn der += Operator hat sowieso eine sehr niedrige Priorität. Aber der Nenner muss geklammert werden - also der Ausdruck mit den Multiplikationen.

So wie das jetzt da steht, wird erst 1 / a gerechnet, und dann das Ergebnis mit (a+1) bzw. (a+2) multipliziert, und das ist ja nicht Sinn der Sache

[absoluteranfänger]

Hallo zusammen,

ich habe jetzt noch einmal 2 Stunden lang Bücher gewälzt, probiert, getestet und experimentiert.

Ich glaube nun habe ich endlich ein ordentliches Ergebnis, das darüber hinaus auch noch richtig ist (kommt mir zumindest so vor ).

...und hier ist es:

#include <stdio.h>


int main (void)

{

    int a;

    double ergebnis;

	ergebnis = 0;

	for ( a = 2; a < 200; a = a + 2)

    {

		ergebnis += 1 / double ( a * (a+1) * (a+2) );


    }

     printf ("Ergebnis: %f\n", ergebnis);

     return 0;

}

Gibt es noch einen Einwand, oder Verbesserungsvorschläge?

Ansonsten mache ich mich schon mal an die nächste Aufgabe

Ich danke euch allen aber jetzt schon einmal, ihr seid echt klasse!!!

[flashpixx]

#include <stdio.h>


int main (void)

{


[I]    int a;

    double ergebnis;

	ergebnis = 0;

[/I]

=> das geht besser: double ergebnis = 0;



[I]	for ( a = 2; a < 200; a = a + 2)[/I]

=> daraus würde ich for(unsigned int a=2; a < 200; a+=2) machen

=> und die beiden {} können weg, da nur ein Befehl nach for ausgeführt wird

	ergebnis += 1 / double ( a * (a+1) * (a+2) );


     printf ("Ergebnis: %f\n", ergebnis);

     return 0;

}

wenn unklar bitte nachfragen

HTH Phil

[TDM]

Gibt es noch einen Einwand, oder Verbesserungsvorschläge?

#include <stdio.h>


int main (void)

{

    double ergebnis [COLOR="Red"]= 0[/COLOR];

    for ([COLOR="Red"]int[/COLOR] a = 2; a < 200; a = a + 2)

    {

		ergebnis += 1[COLOR="Red"].0[/COLOR] / ( a * (a+1) * (a+2) );


    }

     printf ("Ergebnis: %f\n", ergebnis);

     return 0;

}

Nur der besseren Lesbarkeit wegen.

[Klotzkopp]

for (int a = 2;

Hinweis am Rande: Das geht erst seit C99 - manche Compiler mögen das noch nicht.

Der gcc 4 beispielsweise spuckt eine Warnung aus, wenn man das ohne -std=c99 kompiliert.

[TDM]

Hinweis am Rande: Das geht erst seit C99 - manche Compiler mögen das noch nicht.

Ja, aber C89 etc hab ich mal ausgeschlossen.

beim gcc oder irgendeinem Compiler war es glaub ich so, dass bei for(int a [...]) die Variable auch nach der Schleife einen Scope hat.

[Klotzkopp]

beim gcc oder irgendeinem Compiler war es glaub ich so, dass bei for(int a [...]) die Variable auch nach der Schleife einen Scope hat.

Ich glaube, du meinst das (nicht standardkonforme) Verhalten von MS Visual C++ 6.0 und 7.0.

[TDM]

Ich glaube, du meinst das (nicht standardkonforme) Verhalten von MS Visual C++ 6.0 und 7.0.

Nein, ich meine solche Warnungen wie "for-loop scoping outside of C99 mode", keine Ahnung, ob's gcc war.

Aber das der Fehler "Neudefinierte Variable soundso" ist nicht gemeint.

[absoluteranfänger]

Gut, dieses Programm läuft, erfüllt seinen Zweck und ist nun dank eurer Mithilfe auch übersichtlich :cool:

Nun zu einem weiteren Problem - allerdings mit anderer Aufgabenstellung:

Geben Sie an, welche Bildschirmausgabe durch den folgenden Ausschnitt eines C-Programms erzeugt wird:

Nun habe ich den Abschnitt wie folgt "entschlüsselt":

int i,j,k,m,n,p;			/* Festlegung des Datentyps der Variablen i, j, k, m, n und p */

i = 6; 					/* Wertzuweisung: i wird 6 */

j = 2; 					/* Wertzuweisung: j wird 2 */

k = 17; 				/* Wertzuweisung: k wird 17 */

n = 7; 					/* Wertzuweisung: n wird 7 */

p = 11;					/* Wertzuweisung: p wird 11 */


i /= j + 1;				/* Der Wert von j + 1 ist gleich 3, i geteilt durch 3 ergibt 2, Wertzuweisung: i = 2 */

m = (--j) - (n--);			/* Der Wert der Variablen j wird im Voraus um 1 verringert, davon wird der 	


					Wert der Variablen n subtrahiert, deren Wert wiederum im Nachinein um 1 		


					verringert wird, Wertzuweisung m = -6 */


[COLOR="Red"]if (k<20&&p!-11) n = 8;			/* ??? */

[/COLOR]

printf("%d\n", i);			/* Der Rueckgabewert von i ist 2 */

					/* Ausgabe ist eine dezimale ganze Zahl */

					/* 2 wird ausgegeben */

					/* Schreibmarke wird an den Beginn der nächsten Zeile positioniert */


[COLOR="Blue"]printf("%d\n", k&7);			/* Der Rueckgabewert von k ist 17 */

					/* Der Rest der Division von 17 durch 7 ist 3 */

					/* Ausgabe ist eine dezimale ganze Zahl */

					/* 3 wird ausgegeben */

					/* Schreibmarke wird an den Beginn der nächsten Zeile positioniert */[/COLOR]


printf("%d\n", m);			/* Der Rueckgabewert von m ist -6 */

					/* Ausgabe ist eine dezimale ganze Zahl */

					/* -6 wird ausgegeben */

					/* Schreibmarke wird an den Beginn der nächsten Zeile positioniert */


[COLOR="Red"]printf("%d\n", n);			/* Der Rueckgabewert von n ist 8 */

					/* Ausgabe ist eine dezimale ganze Zahl */

					/* 8 wird ausgegeben */

					/* Schreibmarke wird an den Beginn der nächsten Zeile positioniert */[/COLOR]

An der blauen Stelle kann ich nur sagen es handelt sich wohl um einen "Bitoperator", was er bewirkt und wie er funktioniert weiß ich leider nicht. Ich hoffe ihr könnt es mir sagen.

An den roten Stellen komme ich gar nicht weiter. Was passiert dort und in welcher Reihenfolge?