Best way to go about a debug.txt system?

So basically, I want a text file that displays all the processes the program runs up until the time it is closed.. Basically a list of all the functions executed during runtime..

What is the best way about going about this? Should I just make each function when executed write a line to the file?

Say function foo gets executed..

In the debug.txt file it would look like

Running foo
Foo successfully executed..

if it doesn't get to the end of foo

Running foo
Foo failed to execute

(generally if foo fails the program will crash, but this will let me know exactly what went wrong.)


Any suggestions?

I just implemented something like this you can create a generic write function and then #include it in the files you want it used. I have no idea if this is a great idea but it works.

Code:

---

#include "logger.h"

#ifdef DEBUG
    std::ofstream out;
    void Logger(const char *write, bool error)
    {       
        if(error)
        {
            out.open("Error.txt",std::ios::app);
        }
        else
        {           
            out.open("Log.txt",std::ios::app);
        }
        out<<write<<std::endl<<std::endl;
       
        out.close();
       
    }
#endif//DEBUG

#ifndef DEBUG
    void Logger(const char *write, bool error)
    {       
    }
#endif//DEBUG

---

So on a non debug build the code basically does nothing.

> Any suggestions?
Use a debugger.

Logging, as described by prog-bman is more useful in the field, when you want to get some clue (any clue) as to what is going wrong with your program.

But if you're busy writing and testing, a debugger has got to be a better choice, because you can examine much more detail of the internal state of the program.

Here is my system. Essentially the same idea except w/o the debug checks.

Code:

---

#ifndef CLOG
#define CLOG


#include <fstream>
#include <iostream>
using namespace std;


class CLog
{
 
  public:
    ofstream outFile;
    CString strFilename;
    CString strDate;
    CString strTime;

    CLog(void):strFilename(""),strDate(""),strTime("") {}

   
    virtual ~CLog(void)
    {
      outFile.flush();
      outFile.close();
    }

    void Open(CString _filename)
    {
      strFilename=_filename+".txt";

      outFile.open((LPCSTR)strFilename);

      WriteHeader();
   
    }

    void Close(void)
    {
      outFile << endl << "End of file - closing file" << endl;
      outFile.close();
    }

    void WriteHeader(void)
    {
      CTime time=CTime::GetCurrentTime();

      strTime=time.Format("%H:%M:%S %p");
      strDate=time.Format("%a %b %d, %Y");
      outFile << (LPCSTR)strFilename << endl;
      outFile << (LPCSTR)strDate << endl;
      outFile << (LPCSTR)strTime << endl;
      outFile << "****************************************************" << endl;
    }

};

#endif

---

I make the stream public so you can write just about anything you want to it by simply directly accessing the stream. Not much different but these are extremely invaluable classes to have on hand. Simple and yet so powerful. Has helped me track down numerous bugs, leaks, etc.

It uses MFC CString but you can alter that.

Thanks bubba, looks pretty nifty.