Man gibt dabei die Zahl und die Schrittzahl an, wie oft die Intervalle halbiert werden sollen.

Leider wird mir jedoch kein Ergebnis ausgegeben. Es steht nur da
Ergebnis:

Sieht wie folgt aus:

#include <stdio.h>
int main(void)
{
	float zahl, xl, xm, xr, quadrat;
	int i, n;
	printf ("Zahl für Wurzelberechnung:\n");
	scanf("%f", &zahl);
	printf ("Maximale Zahl von Halbierungen:\n");
	scanf("%d", &n);

	for(i=1; i<=n ; i++)
	{
		xr=zahl;
		xl=1;
		xm=(xl+xr)/2;
		quadrat=xm*xm;

		if(quadrat>zahl)
			{
				xr=xm;
				xl=xl;

			}
		else
			{
				xr=xr;
				xl=xm;

			}
	}
	printf ("Ergebnis: %f", xm);
return 0;
}

Wäre super wenn ihr mir Anregungen geben könntet!

Zahl für Wurzelberechnung:
10
Maximale Zahl von Halbierungen:
10
Ergebnis: 30.250000Ergebnis: 30.250000Ergebnis: 30.250000Ergebnis: 30.250000Ergebnis: 30.250000Ergebnis: 30.250000Ergebnis: 30.250000Ergebnis: 30.250000Ergebnis: 30.250000Ergebnis: 30.250000Ergebnis: 5.500000

Könnte man hübscher machen, indem man ein paar \n einfügt, aber sonst... naja das Ergebnis ist auch nicht richtig. Ich glaub die Anweisungen xr=zahl; xl=1; sollten vor der Schleife stehen.

du hast Recht, er gibt mir jetzt ein falsches Ergebnis aus.
Deinen Tipp probier ich mal aus, danke vielmals

Jetzt hab ich ein weiteres Problem:
Bei Zahlen unterhalb der 1 also z.b. 0,75 schießt mir das Programm automatisch bis zum Ende und ich kann nichtmal die Anzahl an Halabierungen mehr definieren.
Ich verstehe das nicht ganz, da ich doch die Variable "Zahl" mit float als Gleitkommazahl definiert habe?

Haste 0,75 oder 0.75 eingegeben?

Leider stimmt das Ergebnis aber nicht
Gebe ich einen Wert unter 1 ein kommt als ergebnis 1,000000 raus?

Das ist ein C-Programm, das zufällig auch gültiges C++ ist.
Die Schleife wird wahrscheinlich zu früh abgebrochen. Die Initialisierung von xr und xl in jedem Schleifendurchlauf dürfte unzweckmäßig sein.
Warum keine Zahl ausgegeben wird, erschliesst sich mir nicht, es sei denn, es wird eine Zahl < 2 für n eingegeben. In diesem Fall ist das Verhalten undefiniert.

Kannst du das mal erklären? Ich sehe es nicht. In der Schleife selbst wird auf n nicht zugegriffen, und die Anzahl an Iterationen kann wohl kaum die Ursache für undefiniertes oder eben auch definiertes Verhalten sein
Edit: Da war eine Bearbeitung ... allerdings Minuten vor deinem Post, also lags nicht daran.

Bei Zahlen unterhalb der 1 also z.b. 0,75 schießt mir das Programm automatisch bis zum Ende und ich kann nichtmal die Anzahl an Halabierungen mehr definieren.
Ich verstehe das nicht ganz, da ich doch die Variable "Zahl" mit float als Gleitkommazahl definiert habe?

Und was gibst du für n ein?
Was heißt, es schießt bis zum Ende? Stürzt es ab, siehst du noch eine Ausgabe (wenn ja, welche), beendet es sich einfach sauber von selbst (Rückgabewert?)?
In Zukunft solche Fehlermeldungen genauer geben

Was macht eigentlich die Selbstzuweisung in Zeile 26 und 21?
Übrigens ist dein Code lupenreines C. Bitte in C++ umschreiben, hier der Anfang:

#include <iostream> /// Die C++ I/O-Streams.

int main() // void für eine leere Parameterliste ist in C++ nicht nötig.
{
    std::cout << "Zahl für Wurzelberechnung:\n";
    float zahl;  // Da deklarieren wo du es zum ersten Mal gebrauchst
    std::cin >> zahl;

    std::cout << "Maximale Zahl von Halbierungen:\n";
    unsigned n; // Mach daraus einen vorzeichenlosen Typen, oder soll der User -1 eingeben können?
    std::cin >> n;

    float xl = 1,
          xr = zahl;

    float xm = 0; // Initialisieren. Wenn du n=0 hast, ist xm sonst irgendein Wert.

    // Wenn du hier 0 statt 1 zuweist, kannst du auch kleiner-als schreiben - wäre direkter
    for(unsigned i=0; i < n; i++) /// i lokaler deklarieren.
    {
        xm = (xl + xr) / 2;

        if(xm*xm > zahl)
            xr=xm;
        else
            xl=xm;
    }

    std::cout << "Ergebnis: " << xm;
} // Rückgabe von 0 in main() nicht nötig.

Wenn ich da 0,75 eingebe springt das Programm ans Ende. Der Grund ist, dass nur bis zum Komma gelesen wird (da es kein Punkt ist, ist es nicht gültig für eine Fließkommazahl*), und dann das Komma und die beiden Ziffern noch im Buffer liegen - bei der Extraktion von n wird dann das Komma gefunden und der Fehlerzustand gesetzt.

Daher könntest du bspw. die Streams nach der(den) Eingabe(n) überprüfen.

*Das ginge mit Locales, das könnte man anpassen.

oh man, ja habs mit Komma eingegeben. Viele Dank!

Leider stimmt das Ergebnis aber nicht
Gebe ich einen Wert unter 1 ein kommt als ergebnis 1,000000 raus?

Weil Du mit xl=1 anfängst.

neonlogist schrieb:

oh man, ja habs mit Komma eingegeben. Viele Dank!

Leider stimmt das Ergebnis aber nicht
Gebe ich einen Wert unter 1 ein kommt als ergebnis 1,000000 raus?

Weil Du mit xl=1 anfängst.

Danke, bin dann auch drauf gekommen und jetzt funktioniert die Wurzelberechnung super.
Nun soll ich jeodch die Zwischenwerte in einer Tabelle wiedergeben.

Die Werte krieg ich z.b. mit %10.5f alle schön tabellarisch hin.
Den Header, also im prinzip die Beschriftung der Tabelle aber krieg ich nicht hin.(ihr wisst was ich mein wenn ihr das Programm bei euch durchlaufen lasst)
Das wirkt in meinen (anfänger) Augen schon sehr schlampig.
Gibt es eine möglichkeit die Werte in eine schön beschriftetet Tabelle zu fassen?
Wir haben mal mit zwei verschachtelten for Schelifen so eine Tabelle erstellt.
Jeodch war das eine"Einmaleins" Tabelle ohne Überschrift und ich weiß eben nicht wie ich meine Zwischenergebnise dort einfügen könnte?

#include <stdio.h>
int main(void)
{
	//Definition der Eingabevariablen//

	float zahl, xl, xm, xr, quadrat, fehler;
	int i, n;
	printf ("Zahl fuer Wurzelberechnung:\n");
	scanf("%f", &zahl);
	printf ("Maximale Zahl von Halbierungen:\n");
	scanf("%d", &n);

	//Differentiation der Eingabevariablen//

	if(zahl<1)
	{
		xl=zahl;
		xr=1;
	}

	else
	{
		xl=1;
		xr=zahl;
	}

	//Tabellen Header//

	printf("      xl    ");
	printf("     xr    ");
	printf("    xm    ");
	printf(" Fehler   \n");

	//Bearbeitungsschleife//

	for(i=0; i<=n; i++)
	{

		//Definitionen Start//

		xm=(xl+xr)/2;
		quadrat=xm*xm;
		fehler=(zahl-(xm*xm))/zahl;
		if(fehler < 0) 
		fehler = (-1)*fehler;

		//Tabelle//

		printf("%10.5f%10.5f%10.5f%10.5f%\n", xl, xr, xm, fehler);

		//Bedingung der Wurzelberechnung//

		if(quadrat>zahl)
			{
				xr=xm;
				xl=xl;
			}
		else
			{
				xr=xr;
				xl=xm;
			}

	}

	//Ende der Schleife//

return 0;
}

Wäre super klasse, wenn ihr mir einen Tipp geben würdet!