Für C++-Programme soll ein allgemein verwendbarer Monitor realisiert werden, welcher die
Aufrufe bestimmter Funktionen protokolliert. Sei z.B. das folgende Programm gegeben:

void f(void)
{
//...
return;
}
main()
{
//...
f();
}

Im Falle der Überwachung von main() und f() soll bei Ausführung des Programms ein Protokoll
der folgenden Form auf dem Bildschirm ausgegeben werden:
Enter main
Enter f
Leave f
Leave main
Zur Realisierung der Monitor-Funktionalität sollen die ausführbaren Anweisungen der zu
überwachenden Funktionen weder verändert noch erweitert werden.

Das Enter main könnte ich hinbekommen indem ich einfach ein

cout << "Enter main";

in den Konstruktor einer Klasse schreib, die ich ganz oben deklarieren könnt. Aber dann der Rest? Ich steh n bissl auf dem schlauch. Kann ich das ebenfalls durch den Einsatz einer Klasse realisieren?

wäre dankbar, wenn mir jemand nen denkanstoss geben kann

SkEaToN schrieb:

Das Enter main könnte ich hinbekommen indem ich einfach ein in den Konstruktor einer Klasse schreib, die ich ganz oben deklarieren könnt.

ist keine klasse sondern eine funktion

ist keine klasse sondern eine funktion

hmm, versteh jetzt net ganz was du meinst was ist keine klasse?

#include <iostream>
using namespace std;

class Monitor
{
 public:
      Monitor();
      ~Monitor();    
};

Monitor::Monitor() { cout << "Enter main" << endl; }
Monitor::~Monitor() { cout << "Leave main" << endl; }

Monitor x;

void f()
{

}

int main()
{
    f();
}

Ein solches Beispiel war auch schonmal in unserem Skript erklärt, aber der Rest ist mir noch unklar. Bin ich mit ner Klasse auf dem richtigen Weg?

/edit: hehe, mir is grad noch eingefallen dass ich Leave main ja mit dem Destruktor machen kann. Bleibt nur noch die f()

class Monitor
{
  std::string fun;
public:
  Monitor(std::string was):fun(was) { cout << "Enter " << was << endl; }
  ~Monitor() { cout << "Leave " << fun << endl; }
}

Aber ich glaube, das würde einen Eingriff in die beobachteten Funktionen bedeuten, der anscheinend verboten ist.

App_dump("2000","text: bla bla bla");

diese funktion ist überall bekannt ( kann überall aufgerufen werden (static) )

der erste parameter kennzeichnet den log range, der 2te den text.

warum log range?

weil wenn ich ein projekt habe mit z.b. 100 klassen ( kein witz! ) dann kann ich z.b. den log aktivieren und angeben welcher bereich gelogt wird

z.b. hab ich ausgemacht das der bereich 100 - 9999 alle db zugriffe sind
1000 - 1499 von main frame aus
1500 - 1600 bla bla bla

dann mach ich noch immer noch ne 10ner unterteilung. damit kann ich jeder fkt 10 verschiedene texte mitgeben

z.b.

void CCustDb::App_CustDB_Connection( ....... )
{

App_dump("200","Enter CCustDb::App_CustDB_Connection");
..

if(blax1 == 1 )
{
App_dump("201","blax1");
}
else
{
App_dump("202","serverIP nicht vorhanden");  // z.b. einfach
}

App_dump("209","Leave CCustDb::App_CustDB_Connection");
}

die App_dump kümmert sich um die protokolierungen auf dem filesystem.

ich hab auch eingeben das die xxx bis xxx log ranges in die datei bblog_db.txt
reinkommen die xxxx bis xxxx in die datei bblog_mainframe.txt ect.

bei der aktivierung geb ich an welche ranges ich loggen will, und nur die werden dann geschrieben, so kann man schön schlang bleiben. allein meine ganzen db zugriffe beim programm start können 300 zeilen logs verurschen. zu beachten ist, dass bei manchen ranges es so eingestellt werden kann dass sofort geschrieben wird. wenn man erst sammeln will und dann schreiben, dann kann es sein, das beim programmabsturz nicht ins filesystem geschrieben wird. da muss man halt einen kompromiss machen.

wie machen es sonst so die anderen hier?