# C++ Fahrenheit in Celsius umrechnen



## Betagurke (16. April 2012)

Hallo Leute, da ich meinen alten Thread nicht mehr finden kann 
habe ich jetzt einfach einen neuen erstellt.

Ich sitze grade an einem Programm, dass Fahrenheit in Celsius umrechnet, mit *einem* festgelegten Fahrenheit Wert klappt das auch, nur möchte ich dass das Programm, 5 Zahlen (10, 20, 30, 40, 50) einließt und daraus dann die Werte bildet. 

Hier der Code: 

```
#include <cstdlib>
#include <iostream>
#include <string>
using namespace std;

int main(int argc, char *argv[])
{
 // c = (f - 32) * 5 / 9 //
 
 double a; 
 double b; 
 double c;
 double d;
 double e;
 double f;
 double x;
 double y;
 double z;
 double l; 
 
 a = 10;
 b = 20;
 d = 30;
 e = 40;
 f = 50; 
 
 c = (f - 32) *5.0 / 9.0;
 x = (e - 32) *5.0 / 9.0; 
 y = (a - 32) *5.0 / 9.0;
 z = (b - 32) *5.0 / 9.0;
 l = (d - 32) *5.0 / 9.0;
 
 cout << f
      << e
      << a
      << b
      << d 
      << e 
      << "Grad Fahrenheit entsprechen"
      << c
      << x
      << y
      << z
      << l
      << "Grad Celsius" <<endl; 
getchar ();

return 0;
}
```

Als Ergebnis bekomme ich alle Zahlen zusammen addiert. 

Danke im Voraus, 
Betagurke


----------



## XT1024 (16. April 2012)

Betagurke schrieb:


> Als Ergebnis bekomme ich alle Zahlen zusammen addiert.


 Nicht addiert sondern die Zeilenumbrüche wurden vergessen.
Ich bin kein C/C++ Held aber nach kurzer Suche habe ich eine funktionierende Lösung gefunden:  << '\n' oder endl dort einfügen, wo eine neue Zeile benötigt wird.
Ob es einen Unterschied gibt oder es nur eine Stilfrage ist 

PS: e wird 2x ausgegeben


----------



## Mashed (16. April 2012)

Einlesen kannst du mit cin, also z.B.

```
int x;
cin >> x;
```
Funktioniert genauso mit anderen Datentypen. Aber Vorsicht: Wenn die Eingabe nicht passt, verbleibt diese im Eingabepuffer, und wird bei der nächsten Verwendung von cin wieder hergenommen. Die eingelesene Variable behält den alten Wert.


----------



## eXodus1989 (17. April 2012)

Hier:

Zwar etwas unschön (könnte man auch mit Schleifen lösen), aber ich denke für dich zum Anfang relativ leicht zu verstehen:


```
#include <iostream>

using namespace std;

int main(){

	float a,b,c,d,e;

		cout << "Wert a: ";
		cin >> a;
		cout << "Wert b: ";
		cin >> b;
		cout << "Wert c: ";
		cin >> c;
		cout << "Wert d: ";
		cin >> d;
		cout << "Wert e: ";
		cin >> e;

		cout << a << " Grad Fahrenheit --> " << ((a - 32 ) * 5 / 9) << " Grad Celsius" << endl;
		cout << b << " Grad Fahrenheit --> " << ((b - 32 ) * 5 / 9) << " Grad Celsius" << endl;
		cout << c << " Grad Fahrenheit --> " << ((c - 32 ) * 5 / 9) << " Grad Celsius" << endl;
		cout << d << " Grad Fahrenheit --> " << ((d - 32 ) * 5 / 9) << " Grad Celsius" << endl;
		cout << e << " Grad Fahrenheit --> " << ((e - 32 ) * 5 / 9) << " Grad Celsius" << endl;

		return 0;
}
```

Wie bereits erwähnt, liest man Eingaben mit "cin" ein.


----------



## Betagurke (17. April 2012)

Danke, ich hätte einfach nur das nächste Video schauen müssen, da wird das mit cin erklärt. Danke trotzdem.


----------



## JoergK (24. April 2012)

XT1024 schrieb:


> Ich bin kein C/C++ Held aber nach kurzer Suche habe ich eine funktionierende Lösung gefunden:  << '\n' oder endl dort einfügen, wo eine neue Zeile benötigt wird.
> Ob es einen Unterschied gibt oder es nur eine Stilfrage ist


Vielleicht hier noch ein kleiner Nachtrag, da ich gerade auf diesen Thread gestoßen sind.
Selbstverständlich gibt es zwischen \n und endl einen Unterschied:
\n stellt das Zeichen für einen Zeilenumbruch dar. Es kann endl hingegen ist ein Manipulator. Er beeinflusst hier direkt den Stream. Durch ihn wird sichergestellt, dass die Ausgabe erfolgt. Dies ist bei \n nicht der Fall.
Allerdings ist dazuzusagen, dass \n schneller ist, da es wie ein normales Zeichen behandelt werden kann.
std::cout << "Hier\nbeginnt eine neue Zeile"; ergäbe also genau wie std::cout << "Hier" << std::endl << "beginnt eine neue Zeile"; die Ausgabe
Hier
beginnt eine neue Zeile

Der eigentliche Unterschied zeigt sich jedoch, wenn man etwas tiefer in die Materie eindringt:
Bei einer einfachen std::cout Anweisung ist nicht gegeben, dass der Text sofort nach Ausführung der Codezeile angezeigt wird, da der Puffer noch nicht voll ist. Allerdings ist es Gang und Gebe, dass der Text vor bestimmten Anweisungen (wie std::cin) die Streams im Hintergrund synchronisiert werden, um überflüssige Bugsuche zu verhindern.

Möchte man sicherstellen, dass die Streams synchronisiert werden und sich nicht blind auf die Synchronisation im Hintergrund verlassen stehen dazu mehrere Möglichkeiten bereit (Folgendes erhebt keinen Anspruch auf Vollständigkeit):
1) Die Methode sync();
2) Mit der Funktion tie kann ich Streams verbinden: std::cin.tie(&std::cout); (synct dann automatisch)
3) Die Flag unitbuf erfüllt ebenfalls diesen Zweck std::cout << unitbuf << "Das ist ein Test"; würde ein solches Umgehen der Synchronisation ebenfalls verhindern (Ist aber meist eh Standardmäßig gesetzt)

Was bleibt also festzuhalten :
\n zwingt nicht dazu den Ausgabepuffer zu leeren. 
endl ist langsamer, aber lässt mich sicherstellen,  dass die Bildschirmausgabe erfolgt (ist also das gleiche wie \n mit anschließendem Aufruf der Methode flush(); )

Hoffe das Ganze ist jetzt was klarer 

Gruß Jörg


----------



## Olstyle (24. April 2012)

Auch wenn es jetzt nicht der Fall war: Das Programm schreit nach copy&paste Fehlern.
Schreib doch eine Methode die die Temperatur in Fahrenheit nimmt und die Temperatur in Celsius zurück gibt.


----------



## Skysnake (25. April 2012)

Zur \n endl Thematik noch was:

Bei endl bedeutet NICHT, das es direkt auf dem Monitor zu sehen ist, sondern nur, das der buffer geflushed wird, und man einen leeren Buffer wieder zum Befüllen hat. Nicht mehr aber auch nicht weniger.

Es kann gerade bei Multithread aber dennoch noch dazu kommen, dass sich die Reihenfolge um dreht in der die Ausgabe dann auf dem Bildschirm erfolgt, oder aber Teile zusammen gepackt werden.

Nur so als kleine Randnotiz.


----------

