C-Programmierung
 

Hey Leute,

da ich im Studium C Programmierung lern,
hab ich ne Frage.
Und zwar hab ich n Programm geschrieben,
in dem eine Endlosschleife immer Werte addiert, und solange durchläuft,
bis ich ne Taste drücke.
Danach schreibt mir das Programm den erreichten Wert in ne Textdatei.
Das alles funktioniert.
Jedoch hab ich jetzt n Problem,
und zwar, wenn das Programm einfach geschlossen wird, dann schreibt es auch nix in die Datei.

Zudem möchte ich eigentlich, dass das Programm die Schleife abbricht, sobald
der PC heruntergefahren wird. Soll also so aussehen:
schleife--------- (Benutzer drückt PC herunterfahren über Start)---Schleife bricht ab---Werte werden gespeichert und Programm schließt sich--- PC kann herunterfahren.

Und wie schaffe ich es, dass mein Programm nur im Hintergrund mitläuft? D.h. dass nicht immer der Tab unten in der Taskleiste sichtbar ist?

Danke im Vorraus.

MfG

JP

Zu deinem Programm beenden Problem:
Ich denke mal Windows schickt beim Runterfahren und beim programm beenden ne Windows Message an dein Programm. Die müsste dein Programm empfangen und entsprechend darauf reagieren.

ok, aber weis jemand wie ich dies auslesen kann?

Habe mich noch nciht weiter mit C beschäftigt (machst du C oder C++)

Aber das hier sieht nicht ganz falsch aus :-)
http://www.fastgraph.com/help/first_c.html

Danke dir für deine schnelle Antworten. Muss aber morgen mal meinen Prof fragen...


Ich mache C.
Bin aber noch ziemlich am Anfang.

Ich verstehe nicht warum du nicht in jedem Schleifendurchlauf in die Datei schreibst. Sofern die Zeitverteilung sinnvoll ist sollte das für ein seltsames Lernbeispiel genügen.
An sonsten schickt Windows Windowmessages: WM_QUERYSHUTDOWN als Frage "darf ich runterfahren?" und dann WM_SHUTDOWN als "ich fahre jetzt runter!"
Wenn du bereits nen Windows-Fenster hast (benutzt du CreateWindow(Ex)?) musst du nur die Nachrichten behandeln.

Wenn du nur nen Shellprogramm schreibst solltest du entsprechende signal-Handler registrieren bzw SetConsoleCtrlHandler benutzen.

Was für Werte willst du überhaupt addieren? (Wenn wir schon am Verbesserungsvorschläge geben sind wärs gut wenn wir das genauer Wissen :-))

Also zum Programmieren verwende ich Visual Studio 2010.
Hab n Programm geschrieben, das mir die Zeit beim PC-Start (also in Autostart rein)
anfängt die Zeit zu zählen, wie lange der Laptop läuft. Denn ich wollt mal ne übersicht,
wie lang ich als Student in der Woche am PC sitz.
Zum reinschreiben öffne ich die Datei mit

FILE*Datei;
Datei=fopen ("C:\\Protokoll.txt", "a+");

d.h. er hängt immer die Zeit hinten dran.
Würd ich den Zugriff schon in der Schleife machen, dann wäre es ja ne ewig lange
Datei, denn jede Sekunde würd gezählt und reingeschrieben werden.

Hier einfach mal kurz den ganzen Code:
#include <Windows.h> //Headerdateien Standart eingebunden
#include <stdint.h>
#include <stdlib.h>
#include <stdio.h>
#include <math.h>
#include <time.h>

int Std=0; //Variablendefinition
int Min=0;
int Sek=0;
int Stop;
char Start[100];

int main () //Main-Schleife
{ do
{
if (Sek>=60)
{
Min++; //Minutenzähler
Sek=00;
}

if (Min>=60) // Stundenzähler
{
Std++;
Min=00;
}

printf ("%02d h %02d min %02d sec", Std, Min,Sek); //Anzeige in Konsole
_sleep (1000);
Sek++; //Sekundenzähler
system ("Cls"); //Bildschirm löschen

if(kbhit()) //Abbruch der Schleife durch drücken einer Taste
{ FILE*Protokoll;
time_t t;
time(&t);
Protokoll=fopen("C:\\Zeitprotokoll.txt","a+"); //Öffnen der Datei und dranhängen
fprintf (Protokoll,"%s",ctime(&t)); //Aktuelle Zeit
fprintf (Protokoll,"%02d h %02d min %02d sec\n\n", Std, Min,Sek); // Einschreiben in Datei
fclose(Protokoll); // Schließen der Datei
_sleep (100);
return 0;}

}while (Stop!=1);

}

Grundsätzlich: Du kannst die Laufzeiten des Systems aus dem Eventlog auslesen. Das sollte dir den ganzen Stress sparen und auch eine rückwärtige Betrachtung ermöglichen.


An sonsten hast du kein Echtzeitsystem, somit wird ein uptime=0; while (true) { ++uptime; sleep(1); } keine verlässlichen Zeiten liefern. Einfach weil sleep(1) durchaus länger als genau eine Sekunde warten wird. Die richtige Herangehensweise wäre die Verwendung der Datumsfunktionen, bspw. GetSystemTime.
An sonsten zwingt dich keiner, bei jedem Schreiben wieder anzuhängen. Du kannst doch innerhalb der Datei seeken oder die Datei jeden Schleifendurchlauf überschreiben.

Ist ne lösung Danke :)
Aber wie würd ich das mit WM_QUERYSHUTDOWN, WM_SHUTDOWN funktioniert?
Kann ich ja durchaus für andere Programme gebrauchen :)

Du würdest beispielsweise ein Einfaches Fenster erstellen (und dann vermutlich nicht anzeigen ->ShowWindow) und dann in der WndProc die beiden Windowmessages behandeln. Das ganze führt jedoch schon relativ tief in Windows-Programmierung.

wieso zählst du überhaupt, wenn du wissen willst wie lange der pc oben ist?
frag doch das system nach der zeit beim start und wieder beim herrunter fahren und schreib die differenz in die datei.

Aufmerksamkeit sollte auf der funktion time liegen.
http://www.cplusplus.com/reference/clibrary/ctime/

das der rest mit der windows api zusammenhängt (mit der ich mich null auskenne) sollte klar sein. also wie man herrausbekommt wann der pc ausgeschalten/ in stand-by geschalten wird.

Ich sehe meine Nachfrage was das Programm machen soll war gerechtfertigt^^. Habe mir schon gedacht dass das irgendwas mit Zeitzählung zu tun hat.

Wir sollte in der Ausbildung damals auch ne Stoppuhr programmieren. Und da wurde auch mit ner Schleife gearbeitet. Auf meine Anmerkung dass das ja nicht genau ist (eben weil Sleep(100) eben nicht immer genau 100ms sind) und dem Vorschlag doch die Differenz zu zählen wurde gesagt dass das aber viele überfordern könnte ...)

Danke für die Vielen Antworten.
Nun, der Timer soll ja nur grob laufen,
sodass ich die Zeit etwas im Auge hab, wie lange ich am PC sitze :P

Nun aber schon wieder ne Frage: :doof:
Mein Projekt soll nun noch die Tastatureingabe im Hintergrund aufzeichnen.
Habe es nun so hinbekommen, dass das Programm die Eingabe aufzeichnet,
und auswertet. Aber nur solange das Fenster im Vordergrund läuft.
Außerdem erkennt es noch keine Zeilensprünge :(
Würde die Auswertung leichter machen, da ich die Wörter später abgleichen
möchte, um so auf spezielle Worteingaben zu reagieren.

Wie kann ich ein Programm im Hintergrund laufen lassen,
was jedoch immer noch auf die Tasteneingabe reagiert?
Und wie erkennt es einen Zeilensprung?


Wäre echt super wenn ihr mir nochmal helfen könntet.
Einlesen tu ichs übrigens so:

if(kbhit())
{ char c = getch();
fprintf (Protokoll,"%c",c);
}
und das ganze als Endlosschleife.


MfG
JP

Einen Keylogger zu bauen ist entweder trivial (mit nen bisschen Googlen findest du dazu sicherlich das ein oder andere fertige Stück Code) oder relativ kompliziert - vermutlich eher jenseits deines momentanen Horizontes.

Wenn du dir das doch mal anschauen willst, schau nach SetWindowsHookEx.
Das ist recht eklig weil du den Handler dafür in ne dll packen musst, damit er in andere Prozesse eingeblendet werden kann. Du brauchst dafür aber auch ein Fenster usw.
Alternativ kannst du checken ob der Bildschirmschoner aktiv ist und damit erkennen ob grad wer am Rechner ist?