Entwickeln Sie ein Programm, das den Ausdruck (Hoch 2, Wurzel aus 2)berechnet
Hinweise zur programmierung:

Erzeugen Sie eine Folge von Positiven Zahlen, deren Quadrate sich der Zahl 2 immer mehr nähren. Führe Sie zu diesem Zweck folgende Anweisungen durch:

1. a=1; b=2
2. c=(a+b)/2
3. Wenn c*c>2 dann b=c
   sonst a=c
4. weiter bei 1.

So uns wurde zusätzlich gesagt das wir als schleife die for schleife verwenden sollen, nur leider weis ich nicht wie ich das programm umsätzen soll, ich sitz bereits seit 2 Tagen dran, bekomm das aber nie raus.

Danke schonmal für eure Hilfe.

#include <stdio.h>

main()
{
	int a=1, b=2, c;
	printf("\n\tProgramm zur Berechnung von Wurzel 2");

		for(c=(a+b)/2; c*c>2; c=c*c);
		{
		b=c;
		}
		printf("\n\n");
		printf("\tWurzel 2= %i",b);
}

Ich hab mir das in etwa so gedacht, nur leider weis ich net, wie ich das jetzt mit der For schleife machen soll.
Wir haben gerade erst damit angefangen.

1. Erste Lektion: Wie funktionieren Schleifen?
2. Zweite Lektion: Wie funktioniert eine Verzweigung? (wenn/dann/sonst)

Das "4) weiter bei 1." macht aber sowieso keinen Sinn, weil dann ja immer das gleiche gerechnet wird.

1. a=1; b=2

Der Teil kommt vor die Schleife, um die beteiligten Variablen zu initialisieren

2. c=(a+b)/2
3. Wenn c*c>2 dann b=c
   sonst a=c

Der Teil kommt als Anweisung in den Schleifenrumpf

4. weiter bei 1.

Das sollte wohl eher "weiter bei 2." heißen - und stellt den Schleifenkopf dar. Außerdem solltest du dir noch ein Abbruchkriterium überlegen, mit dem du die Schleife verlassen kannst.

(PS: Für die Aufgabe würde ich eher eine do-while-Schleife verwenden)

#include <iostream>

double radical(double value, std::size_t approx)
{
	if (value == 0.0 || value == 1.0) return value;

	double a = 1.0, b = 2.0;
	for (; approx > 0; --approx)
	{
		double c = ((a + b) / 2.0);
		if ((c * c) > 2.0)
			b = c;
		else 
			a = c;
	}
	return a;
}

int main()
{
	std::cout	<< "Wuzel² Berechnung V0.1\n"
				<< "Zahl: " << std::flush;
	double value = 0.0;
	std::cin >> value;
	std::cout	<< "Annäherungen: " << std::flush;
	std::size_t approx = 1;
	std::cin >> approx;
	std::cout << radical(value, approx) << std::endl;
}

... ist allerdings nen komischer Algo ^^

namespace math
{
	template <typename T>
	T power(T const& value, std::size_t expo)
	{	return value * power<T>(value, expo - 1);	}
};

... ist nicht die beste Implementierung ... aber sollte gehen