!!Hilfe Stoppuhr im Taschenrechner einbauen !!

[MadaraUchia]

Hi
Wie oben beschrieben ist will ich eine stopuhr einbauen im Taschenrechner .
Leider habe ich keine Ahnung wie man eine Stoppuhr baut??
Es sollte wenn ein Ergebnis kommt wie z.B 1000+2000 = 3000 und dann sollte die Zeit eingegeben werden wie schnell er auf das Ergebnis kam in ms wenn es möglich ist auch in micro sec. angegeben .

Hier ist der Code :[code]
#include "stdafx.h"
#include <iostream>

#include <iostream>
using namespace std;

int addieren(int a, int b)
{
return(a + b);
}

int subtrahieren(int a, int b)
{
return(a - b);
}

int dividieren(int a, int b)
{
return(a / b);
}

int multiplizieren(int a, int b )
{
return(a * b);
}

int main()
{
char entscheidung;
int zahl1, zahl2;

cout << "Ein einfaches Rechenprogramm mit ganzen Zahlen" << endl << endl;

for (int i = 1; i > 0;)
{

cout << "Menue bitte auswaehlen:" << endl;
cout << "(A)Addieren" << endl;
cout << "(D)Dividieren" << endl;
cout << "(M)Multiplizieren"<< endl;
cout << "(S)Subtrahieren" << endl << endl;
cout << "(B)Beenden" << endl << endl;

cin >> entscheidung;

switch (entscheidung)
{
case 'A':
case 'a':
cout << "Bitte geben Sie die zwei Zahlen ein, die Sie miteinander addieren moechten: " << endl;
cin >> zahl1;
cin >> zahl2;
cout << "Ergebnis: ";
cout << addieren(zahl1, zahl2) << endl << endl;
break;

case 'D':
case 'd':
cout << "Bitte geben Sie die zwei Zahlen ein, die Sie miteinander dividieren moechten: " << endl;
cin >> zahl1;
cin >> zahl2;
cout << "Ergebnis: ";
cout << dividieren(zahl1, zahl2) << endl << endl;
break;

case 'M':
case 'm':
cout << "Bitte geben Sie die zwei Zahlen ein, die Sie miteinander multiplizieren moechten: " << endl;
cin >> zahl1;
cin >> zahl2;
cout << "Ergebnis: ";
cout << multiplizieren(zahl1, zahl2) << endl << endl;
break;

case 'S':
case 's':
cout << "Bitte geben Sie die zwei Zahlen ein, die Sie miteinander subtrahieren moechten: " << endl;
cin >> zahl1;
cin >> zahl2;
cout << "Ergebnis: ";
cout << subtrahieren (zahl1, zahl2) << endl << endl;
break;

case 'B':
case 'b':
return 0;

default:
cout << endl << "Ungueltiger Wert" << endl << "Bitte versuchen Sie es erneut: " << endl << endl;
}
}
}

[CStoll]

Erstens: Dein Code ist kein CLI, sondern reines C++

Zeitens: Dein Code steckt voller redundanter Teile, sowas kann man doch zusammenfassen.

Drittens: Schau dir mal die Funktion clock() an. Aber ob die Laufzeit der Rechenfunktionen überhaupt messbar ist, wage ich zu bezweifeln

[MadaraUchia]

Hi danke !!

[ZeroXCola]

Hallo MadaraUchia,

hier sind erstmal die verfügbaren Timer:

Das Betriebsystem stellt mehrere Zeitgeber mit verschiedenen Genauigkeitsstufen zur Verfügung:

Funktion Einheit Genauigkeit
---------------------------------------------------------------------------
Now, Time, Timer Sekunden 1 Sekunde
GetTickCount Millisekunden ca. 10 ms
TimeGetTime Millisekunden ca. 10 ms
QueryPerformanceCounter QueryPerformanceFrequency gleich

Beitrag aus Support.Microsoft-Seite.

Hier meine QueryPerformanceCounter-Klasse. Hoffe, du verstehst sie.
Für eine Umnwaldung von double in int wurde die System lib benutzt.

class Time
{
private: LONGLONG g_frequenz, g_startpunkt, g_letztemessung;
private: int temp;

	///Speichert die Zeitdifferenz Zwischen startpunkt und letzter Messung.
	/** Wird nach Aufruf von SetStart und GetFrequenz, Messe, sowie 
            Vergleiche befüllt. */
private: double dTimeDiff;

	///Liest die derzeitige Frequenz aus.
	/** Wird von SetStart ausgelesen, damit die aktuelle Frequenz benutzt wird nicht bei Objekterstellung. 
	@ return g_frequenz*/
private: void Time::GetFrequenz()
	{
		QueryPerformanceFrequency((LARGE_INTEGER*)&g_frequenz);
	}

	///Speichert die derzeitige Tickzahl.
	/** @return g_letztemessung */
private: void Time::Messe()
	{
		QueryPerformanceCounter((LARGE_INTEGER*)&g_letztemessung);
	}

	///Errechnet dTimeDiff
	/** Nimmt die Differenz zweier Ticker und teilt sie durch die Frequenz, die ein Tick braucht,
	um die Zeitdifferenz in Sekunden auszugeben.
	@param g_startpunkt 1.Messpunkt
	@param g_letztemessung 2. Messpunkt
	@param g_frequenz Frequenz pro Tick
	@return dTimeDiff*/
public: void Vergleiche()
	{
		dTimeDiff = (((double)(g_letztemessung-g_startpunkt))/((double)g_frequenz));
	}

	///Setzt g_startpunkt
	/** @return g_startpunkt */
public: void Time::SetStart()
	{
		GetFrequenz();
		QueryPerformanceCounter((LARGE_INTEGER*)&g_startpunkt);
	}

	///Schaut ob schon "Zeitdifferenz" verstrichen ist.
	/** Nach Aufruf von SetStart benutzbar. Vergleicht Startzeit mit jetziger Zeit.
	@param SetStart();
	@return Zeitdifferenz schon verstrichen. */
public: bool Timer(double Wartezeit)
	{
		Messe();
		Vergleiche();
		if(Wartezeit<dTimeDiff)
			return true;
		else
			return false;
	}

	///Gibt die Zeitdifferenz zwischen startpunkt und Jetziger Zeit aus.
	/** Nach Aufruf von SetStart benutzbar. Vergleicht Starzeit mit jetziger Zeit und gibt Zeitdifferenz zurück. 
	@param SetStart muss aufgerufen worden sein.
	@return dTimeDiff Zeitdifferenz*/
         //Gibt Zeit in double-aus.
public: double GetTimeDiff()
		{
			Messe();
			Vergleiche();
			return dTimeDiff;
		}

         //Gibt Zeit in Sekunden aus.
public: int Get1_1SecForAufruf()
		{
			Messe();
			Vergleiche();
			temp = System::Convert::ToInt64(GetTimeDiff());
			return temp;
		}

            //Aktualisiere, Get1_1Sec, Get1_10Sec und Get1_100Sec sind für
            //meinen Timer, der bei mir 3 Stellen hat. die erste für Sekunden,
            //die zweite für 1/10 Sekunden, die dritte für 1/100 Sekunden. Bevor
            //die Get-Funktionen aufgerufen werden dürfen, muss immer mit
            //Aktualisiere die Aktuelle Zeit ausgelesen werden.
public: void Aktualisiere()
		{
			Messe();
			Vergleiche();
			temp = System::Convert::ToInt64(dTimeDiff*100);
		}       
public: int Get1_1Sec()
		{
			return temp/100;
		}
public: int Get1_10Sec()
		{
			return (temp%100)/10;
		}
public: int Get1_100Sec()
		{
			return (temp%10)/1;
		}
	///Legt den Startpunkt fest.
	/** Wird dazu verwendet, den Startpunkt nach dem Laden neu zu setzen. */
public: void SetTimeDifferenz(int Diff)
		{
			Messe();
			g_startpunkt=g_letztemessung-Diff*g_frequenz;
		}
};