ich schreibe mir gerade einen Function Tacker, der mir alle augerufenen Funktionen in einem vektor speichert. Ich habe eine Klasse A, die den statischen vektor und die statischen Funktionen, um in den vektor zu schreiben und aus ihm elemente zu löschen, besitzt.
Daneben existiert eine Klasse B, die beim instanzieren im Konstruktor die statische Funktion zum speichern des Funktionsnamen von Klasse A aufruft und im Destruktor dann die statische Funktion von Klasse A aufruft, um den Funktionsnamen wieder zu löschen.
Code: Alles auswählen
class A{
friend class B;
private:
static std::vector<const char*> _stringVectorGlobal;
static void _pushFunction(const char* l_FuncName);
static void _popFunction();
public:
A() {}
};
class B{
public:
B(const char* l_FuncName){
A::_pushFunction(l_FuncName);
}
~B(){
A::_popFunction();
}
};
Diesen FunktionsTracker möchte in einer eigenen lib speichern, die ich dann in anderen eigenen libs verwende.
Zusätzlich will ich das Tracken in eigenen Projekten an und ausschalten. Wenn das Programm also erstmal fehlerfrei läuft, dann schalt ich den Tracker aus und spare somit ein wenig Rechenzeit und Speicher.
Meine Frage ist nun, wie ich das umsetzen kann?
Einerseits könnte man es mit Präprozessdirektiven in der FunctionTracker-Lib lösen
Code: Alles auswählen
#if DEFINE_FUNCTIONTRACKER
#define track() static const char *INTERNAL_FUNCNAME = __FUNCTION__; \
B INTERNAL_TRACK(INTERNAL_FUNCNAME);
#else
#define track()
#endif
Code: Alles auswählen
#define DEFINE_FUNCTIONTRACKER 1
Ein andere Lösung wäre mit Templates:
Code: Alles auswählen
template <bool>
class B
{
public:
B( const char* l_FuncName ) : _param( l_FuncName ) { A::_pushFunction( l_FuncName ); }
~B() { A::_popFunction( l_FuncName); }
private:
const char* _FuncName;
};
template <>
class B <false>
{
public:
B( const char* l_FuncName) {}
~B() {}
};
Code: Alles auswählen
static bool A::log = true;
Somit könnte ich zu Beginn eines jeden Projekts A::log setzen, um zu tracken (true) oder es sein zu lassen (false). Beim letzteren Fall (false) weiss ich aber nun nicht, ob die Instanzierung wegoptimiert wird, um somit Ressourcen und Rechnzeit zu sparen.
Weiss jemand, ob dies der Fall ist oder wie ich das sicher ermitteln kann oder hat vlt. jemand einen ganz anderen Ansatz?